@flanksource/clicky-ui 0.3.33 → 0.3.35

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

@@ -1 +1 @@
-{"version":3,"file":"use-task-run.js","sources":["../../src/hooks/use-task-run.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport {\n  allGroupsTerminal,\n  type TaskRunMeta,\n  type TaskSnapshot,\n} from \"../data/TaskSnapshot\";\nimport { taskQueryKeys } from \"../data/task-query-keys\";\n\n// use-task-run / use-task-runs are the generic clicky-ui task clients. They are\n// SSE-first: they subscribe to clicky's SSEHandler (event: task / event: done)\n// and fall back to polling the JSON endpoints only when EventSource is\n// unavailable. They speak only TaskSnapshot / TaskRunMeta — no app concepts.\n\nexport interface TaskTransportOptions {\n  /** Base path of the clicky task API, e.g. \"/api/v1\". */\n  basePath?: string | undefined;\n  /** Disable the subscription entirely (e.g. before an id is known). */\n  enabled?: boolean | undefined;\n  /** Poll interval (ms) for the fallback / runs listing. */\n  pollMs?: number | undefined;\n  /** Force the polling transport even when EventSource exists (mainly tests). */\n  forcePoll?: boolean | undefined;\n}\n\nconst DEFAULT_BASE = \"/api/v1\";\nconst DEFAULT_POLL_MS = 2_000;\n\nfunction streamUrl(base: string, query: string): string {\n  return `${base}/tasks/stream${query ? `?${query}` : \"\"}`;\n}\n\nfunction hasEventSource(): boolean {\n  return typeof globalThis !== \"undefined\" && typeof globalThis.EventSource !== \"undefined\";\n}\n\nexport interface UseTaskRunResult {\n  snapshots: TaskSnapshot[];\n  status: string;\n  isComplete: boolean;\n}\n\nexport interface UseTaskRunOptions extends TaskTransportOptions {\n  /** Stable run id to follow (drill-down). Mutually exclusive with ids/kind. */\n  id?: string | undefined;\n  /** Stable run ids to follow together. Mutually exclusive with id/kind. */\n  ids?: string[] | undefined;\n  /** Follow every run of a kind. */\n  kind?: string | undefined;\n}\n\n// useTaskRun follows one or more runs (by id) or a kind, SSE-first. It accumulates the\n// latest snapshot per task/group id and reports completion once every group is\n// terminal.\nexport function useTaskRun(options: UseTaskRunOptions = {}): UseTaskRunResult {\n  const {\n    id,\n    ids,\n    kind,\n    basePath = DEFAULT_BASE,\n    enabled = true,\n    pollMs = DEFAULT_POLL_MS,\n    forcePoll = false,\n  } = options;\n  const runIdsKey = (ids?.filter(Boolean) ?? (id ? [id] : [])).join(\",\");\n\n  const [byId, setById] = useState<Record<string, TaskSnapshot>>({});\n  const [status, setStatus] = useState(\"idle\");\n  const [isComplete, setIsComplete] = useState(false);\n\n  useEffect(() => {\n    const runIds = runIdsKey ? runIdsKey.split(\",\") : [];\n    if (!enabled || (runIds.length === 0 && !kind)) {\n      setById({});\n      setStatus(\"idle\");\n      setIsComplete(false);\n      return;\n    }\n    setById({});\n    setIsComplete(false);\n\n    const params = new URLSearchParams();\n    if (runIds.length > 0) params.set(\"tasks\", runIdsKey);\n    if (kind) params.set(\"kind\", kind);\n    const query = params.toString();\n\n    const merge = (incoming: TaskSnapshot[]) => {\n      setById((prev) => {\n        const next = { ...prev };\n        for (const snap of incoming) next[snap.id] = snap;\n        return next;\n      });\n    };\n\n    const mergeOutput = (delta: {\n      id: string;\n      stream: \"stdout\" | \"stderr\";\n      data: string;\n      reset?: boolean;\n      truncated?: boolean;\n    }) => {\n      setById((prev) => {\n        const snapshot = prev[delta.id];\n        if (!snapshot) return prev;\n        const value = delta.reset ? delta.data : `${snapshot[delta.stream] ?? \"\"}${delta.data}`;\n        const truncatedField = delta.stream === \"stdout\" ? \"stdoutTruncated\" : \"stderrTruncated\";\n        return {\n          ...prev,\n          [delta.id]: {\n            ...snapshot,\n            [delta.stream]: value,\n            [truncatedField]: delta.truncated ?? snapshot[truncatedField],\n          },\n        };\n      });\n    };\n\n    // Polling fallback transport.\n    if (forcePoll || !hasEventSource()) {\n      let stopped = false;\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      const tick = async () => {\n        try {\n          const responses = await Promise.all(runIds.map((runId) => fetch(\n            `${basePath}/tasks/${encodeURIComponent(runId)}`,\n            { headers: { Accept: \"application/json\" } },\n          )));\n          if (responses.every((response) => response.ok)) {\n            const snaps = (await Promise.all(responses.map(\n              async (response) => (await response.json()) as TaskSnapshot[],\n            ))).flat();\n            if (stopped) return;\n            merge(snaps);\n            setStatus(\"polling\");\n            if (allGroupsTerminal(snaps)) {\n              setIsComplete(true);\n              return; // stop polling\n            }\n          }\n        } catch {\n          if (!stopped) setStatus(\"connection lost — retrying\");\n        }\n        if (!stopped) timer = setTimeout(tick, pollMs);\n      };\n      void tick();\n      return () => {\n        stopped = true;\n        if (timer) clearTimeout(timer);\n      };\n    }\n\n    // SSE transport (default).\n    const es = new EventSource(streamUrl(basePath, query));\n    setStatus(\"connected\");\n    es.addEventListener(\"task\", (e) => {\n      try {\n        merge([JSON.parse((e as MessageEvent).data) as TaskSnapshot]);\n      } catch {\n        /* ignore malformed frame */\n      }\n    });\n    es.addEventListener(\"output\", (e) => {\n      try {\n        mergeOutput(JSON.parse((e as MessageEvent).data) as Parameters<typeof mergeOutput>[0]);\n      } catch {\n        /* ignore malformed frame */\n      }\n    });\n    es.addEventListener(\"done\", () => {\n      setStatus(\"complete\");\n      setIsComplete(true);\n      es.close();\n    });\n    es.onerror = () => setStatus(\"connection lost — retrying\");\n    return () => es.close();\n  }, [runIdsKey, kind, basePath, enabled, pollMs, forcePoll]);\n\n  return { snapshots: Object.values(byId), status, isComplete };\n}\n\nexport interface UseTaskRunsOptions extends TaskTransportOptions {\n  kind?: string | undefined;\n  status?: string | undefined;\n  /** Label equality filters (k=v). */\n  labels?: Record<string, string> | undefined;\n}\n\n/** The identity of the listing request that produced a given `runs` array. */\nexport type TaskRunsKey = ReturnType<typeof taskQueryKeys.runs>;\n\nexport interface UseTaskRunsResult {\n  runs: TaskRunMeta[];\n  status: string;\n  /**\n   * Query key of the request that actually produced `runs`, or null before the\n   * first frame arrives. Changing `kind`/`status`/`labels` re-subscribes but\n   * keeps the previous listing on screen until the new transport delivers, so\n   * this key lags `taskQueryKeys.runs(options)` during that window. A consumer\n   * mirroring `runs` into a cache must compare the two and skip the write while\n   * they differ, or it publishes rows that do not match the requested filters.\n   */\n  runsKey: TaskRunsKey | null;\n}\n\n// useTaskRuns lists all runs (TaskRunMeta) for the manager view. It is SSE-first:\n// it subscribes to clicky's runs stream (event: runs carrying the full listing)\n// and falls back to polling the JSON runs endpoint only when EventSource is\n// unavailable or forced off. The listing has no completion terminal of its own —\n// a manager view stays subscribed to observe new and changing runs.\nexport function useTaskRuns(options: UseTaskRunsOptions = {}): UseTaskRunsResult {\n  const {\n    kind,\n    status: statusFilter,\n    labels,\n    basePath = DEFAULT_BASE,\n    enabled = true,\n    pollMs = DEFAULT_POLL_MS,\n    forcePoll = false,\n  } = options;\n\n  // Runs are stored together with the key of the request that delivered them, so\n  // a stale listing can never be mistaken for the current filters' result.\n  const [received, setReceived] = useState<{\n    key: TaskRunsKey | null;\n    runs: TaskRunMeta[];\n  }>({ key: null, runs: [] });\n  const [status, setStatus] = useState(\"idle\");\n\n  useEffect(() => {\n    if (!enabled) return;\n\n    const params = new URLSearchParams();\n    if (kind) params.set(\"kind\", kind);\n    if (statusFilter) params.set(\"status\", statusFilter);\n    for (const [k, v] of Object.entries(labels ?? {})) params.append(\"label\", `${k}=${v}`);\n    const query = params.toString();\n    const requestKey = taskQueryKeys.runs({ basePath, kind, status: statusFilter, labels });\n    const receive = (next: TaskRunMeta[]) => setReceived({ key: requestKey, runs: next });\n\n    // Polling fallback transport.\n    if (forcePoll || !hasEventSource()) {\n      let stopped = false;\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      const tick = async () => {\n        try {\n          const res = await fetch(`${basePath}/tasks${query ? `?${query}` : \"\"}`, {\n            headers: { Accept: \"application/json\" },\n          });\n          if (res.ok) {\n            const next = (await res.json()) as TaskRunMeta[];\n            if (stopped) return;\n            receive(next);\n            setStatus(\"polling\");\n          }\n        } catch {\n          if (!stopped) setStatus(\"connection lost — retrying\");\n        }\n        if (!stopped) timer = setTimeout(tick, pollMs);\n      };\n      void tick();\n      return () => {\n        stopped = true;\n        if (timer) clearTimeout(timer);\n      };\n    }\n\n    // SSE transport (default).\n    const es = new EventSource(`${basePath}/tasks/runs/stream${query ? `?${query}` : \"\"}`);\n    setStatus(\"connected\");\n    es.addEventListener(\"runs\", (e) => {\n      try {\n        receive(JSON.parse((e as MessageEvent).data) as TaskRunMeta[]);\n      } catch {\n        /* ignore malformed frame */\n      }\n    });\n    es.onerror = () => setStatus(\"connection lost — retrying\");\n    return () => es.close();\n  }, [kind, statusFilter, JSON.stringify(labels ?? {}), basePath, enabled, pollMs, forcePoll]);\n\n  return { runs: received.runs, status, runsKey: received.key };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-task-run.js","sources":["../../src/hooks/use-task-run.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport {\n  allGroupsTerminal,\n  type TaskRunMeta,\n  type TaskSnapshot,\n} from \"../data/TaskSnapshot\";\nimport { taskQueryKeys } from \"../data/task-query-keys\";\n\n// use-task-run / use-task-runs are the generic clicky-ui task clients. They are\n// SSE-first: they subscribe to clicky's SSEHandler (event: task / event: done)\n// and fall back to polling the JSON endpoints only when EventSource is\n// unavailable. They speak only TaskSnapshot / TaskRunMeta — no app concepts.\n\nexport interface TaskTransportOptions {\n  /** Base path of the clicky task API, e.g. \"/api/v1\". */\n  basePath?: string | undefined;\n  /** Disable the subscription entirely (e.g. before an id is known). */\n  enabled?: boolean | undefined;\n  /** Poll interval (ms) for the fallback / runs listing. */\n  pollMs?: number | undefined;\n  /** Force the polling transport even when EventSource exists (mainly tests). */\n  forcePoll?: boolean | undefined;\n}\n\nconst DEFAULT_BASE = \"/api/v1\";\nconst DEFAULT_POLL_MS = 2_000;\n\nfunction streamUrl(base: string, query: string): string {\n  return `${base}/tasks/stream${query ? `?${query}` : \"\"}`;\n}\n\nfunction hasEventSource(): boolean {\n  return typeof globalThis !== \"undefined\" && typeof globalThis.EventSource !== \"undefined\";\n}\n\nexport interface UseTaskRunResult {\n  snapshots: TaskSnapshot[];\n  status: string;\n  isComplete: boolean;\n}\n\nexport interface UseTaskRunOptions extends TaskTransportOptions {\n  /** Stable run id to follow (drill-down). Mutually exclusive with ids/kind. */\n  id?: string | undefined;\n  /** Stable run ids to follow together. Mutually exclusive with id/kind. */\n  ids?: string[] | undefined;\n  /** Follow every run of a kind. */\n  kind?: string | undefined;\n}\n\n// useTaskRun follows one or more runs (by id) or a kind, SSE-first. It accumulates the\n// latest snapshot per task/group id and reports completion once every group is\n// terminal.\nexport function useTaskRun(options: UseTaskRunOptions = {}): UseTaskRunResult {\n  const {\n    id,\n    ids,\n    kind,\n    basePath = DEFAULT_BASE,\n    enabled = true,\n    pollMs = DEFAULT_POLL_MS,\n    forcePoll = false,\n  } = options;\n  const runIdsKey = (ids?.filter(Boolean) ?? (id ? [id] : [])).join(\",\");\n\n  const [byId, setById] = useState<Record<string, TaskSnapshot>>({});\n  const [status, setStatus] = useState(\"idle\");\n  const [isComplete, setIsComplete] = useState(false);\n\n  useEffect(() => {\n    const runIds = runIdsKey ? runIdsKey.split(\",\") : [];\n    if (!enabled || (runIds.length === 0 && !kind)) {\n      setById({});\n      setStatus(\"idle\");\n      setIsComplete(false);\n      return;\n    }\n    setById({});\n    setIsComplete(false);\n\n    const params = new URLSearchParams();\n    if (runIds.length > 0) params.set(\"tasks\", runIdsKey);\n    if (kind) params.set(\"kind\", kind);\n    const query = params.toString();\n\n    const merge = (incoming: TaskSnapshot[]) => {\n      setById((prev) => {\n        const next = { ...prev };\n        for (const snap of incoming) next[snap.type === \"group\" ? `group:${snap.groupId ?? snap.id}` : snap.id] = snap;\n        return next;\n      });\n    };\n\n    const mergeOutput = (delta: {\n      id: string;\n      stream: \"stdout\" | \"stderr\";\n      data: string;\n      reset?: boolean;\n      truncated?: boolean;\n    }) => {\n      setById((prev) => {\n        const snapshot = prev[delta.id];\n        if (!snapshot) return prev;\n        const value = delta.reset ? delta.data : `${snapshot[delta.stream] ?? \"\"}${delta.data}`;\n        const truncatedField = delta.stream === \"stdout\" ? \"stdoutTruncated\" : \"stderrTruncated\";\n        return {\n          ...prev,\n          [delta.id]: {\n            ...snapshot,\n            [delta.stream]: value,\n            [truncatedField]: delta.truncated ?? snapshot[truncatedField],\n          },\n        };\n      });\n    };\n\n    // Polling fallback transport.\n    if (forcePoll || !hasEventSource()) {\n      let stopped = false;\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      const tick = async () => {\n        try {\n          const responses = await Promise.all(runIds.map((runId) => fetch(\n            `${basePath}/tasks/${encodeURIComponent(runId)}`,\n            { headers: { Accept: \"application/json\" } },\n          )));\n          if (responses.some((response) => !response.ok)) throw new Error(\"Task request failed\");\n          if (responses.every((response) => response.ok)) {\n            const snaps = (await Promise.all(responses.map(\n              async (response) => (await response.json()) as TaskSnapshot[],\n            ))).flat();\n            if (stopped) return;\n            merge(snaps);\n            setStatus(\"polling\");\n            if (allGroupsTerminal(snaps)) {\n              setIsComplete(true);\n              return; // stop polling\n            }\n          }\n        } catch {\n          if (!stopped) setStatus(\"connection lost — retrying\");\n        }\n        if (!stopped) timer = setTimeout(tick, pollMs);\n      };\n      void tick();\n      return () => {\n        stopped = true;\n        if (timer) clearTimeout(timer);\n      };\n    }\n\n    // SSE transport (default).\n    const es = new EventSource(streamUrl(basePath, query));\n    setStatus(\"connecting\");\n    es.onopen = () => setStatus(\"connected\");\n    es.addEventListener(\"task\", (e) => {\n      try {\n        merge([JSON.parse((e as MessageEvent).data) as TaskSnapshot]);\n        setStatus(\"connected\");\n      } catch {\n        setStatus(\"invalid task stream data\");\n      }\n    });\n    es.addEventListener(\"output\", (e) => {\n      try {\n        mergeOutput(JSON.parse((e as MessageEvent).data) as Parameters<typeof mergeOutput>[0]);\n      } catch {\n        setStatus(\"invalid task output data\");\n      }\n    });\n    es.addEventListener(\"done\", () => {\n      setStatus(\"complete\");\n      setIsComplete(true);\n      es.close();\n    });\n    es.onerror = () => setStatus(\"connection lost — retrying\");\n    return () => es.close();\n  }, [runIdsKey, kind, basePath, enabled, pollMs, forcePoll]);\n\n  return { snapshots: Object.values(byId), status, isComplete };\n}\n\nexport interface UseTaskRunsOptions extends TaskTransportOptions {\n  kind?: string | undefined;\n  status?: string | undefined;\n  /** Label equality filters (k=v). */\n  labels?: Record<string, string> | undefined;\n}\n\n/** The identity of the listing request that produced a given `runs` array. */\nexport type TaskRunsKey = ReturnType<typeof taskQueryKeys.runs>;\n\nexport interface UseTaskRunsResult {\n  runs: TaskRunMeta[];\n  status: string;\n  /**\n   * Query key of the request that actually produced `runs`, or null before the\n   * first frame arrives. Changing `kind`/`status`/`labels` re-subscribes but\n   * keeps the previous listing on screen until the new transport delivers, so\n   * this key lags `taskQueryKeys.runs(options)` during that window. A consumer\n   * mirroring `runs` into a cache must compare the two and skip the write while\n   * they differ, or it publishes rows that do not match the requested filters.\n   */\n  runsKey: TaskRunsKey | null;\n}\n\n// useTaskRuns lists all runs (TaskRunMeta) for the manager view. It is SSE-first:\n// it subscribes to clicky's runs stream (event: runs carrying the full listing)\n// and falls back to polling the JSON runs endpoint only when EventSource is\n// unavailable or forced off. The listing has no completion terminal of its own —\n// a manager view stays subscribed to observe new and changing runs.\nexport function useTaskRuns(options: UseTaskRunsOptions = {}): UseTaskRunsResult {\n  const {\n    kind,\n    status: statusFilter,\n    labels,\n    basePath = DEFAULT_BASE,\n    enabled = true,\n    pollMs = DEFAULT_POLL_MS,\n    forcePoll = false,\n  } = options;\n\n  // Runs are stored together with the key of the request that delivered them, so\n  // a stale listing can never be mistaken for the current filters' result.\n  const [received, setReceived] = useState<{\n    key: TaskRunsKey | null;\n    runs: TaskRunMeta[];\n  }>({ key: null, runs: [] });\n  const [status, setStatus] = useState(\"idle\");\n\n  useEffect(() => {\n    if (!enabled) return;\n\n    const params = new URLSearchParams();\n    if (kind) params.set(\"kind\", kind);\n    if (statusFilter) params.set(\"status\", statusFilter);\n    for (const [k, v] of Object.entries(labels ?? {})) params.append(\"label\", `${k}=${v}`);\n    const query = params.toString();\n    const requestKey = taskQueryKeys.runs({ basePath, kind, status: statusFilter, labels });\n    const receive = (next: TaskRunMeta[]) => setReceived({ key: requestKey, runs: next });\n\n    // Polling fallback transport.\n    if (forcePoll || !hasEventSource()) {\n      let stopped = false;\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      const tick = async () => {\n        try {\n          const res = await fetch(`${basePath}/tasks${query ? `?${query}` : \"\"}`, {\n            headers: { Accept: \"application/json\" },\n          });\n          if (!res.ok) throw new Error(`Task listing failed with ${res.status}`);\n          if (res.ok) {\n            const next = (await res.json()) as TaskRunMeta[];\n            if (stopped) return;\n            receive(next);\n            setStatus(\"polling\");\n          }\n        } catch {\n          if (!stopped) setStatus(\"connection lost — retrying\");\n        }\n        if (!stopped) timer = setTimeout(tick, pollMs);\n      };\n      void tick();\n      return () => {\n        stopped = true;\n        if (timer) clearTimeout(timer);\n      };\n    }\n\n    // SSE transport (default).\n    const es = new EventSource(`${basePath}/tasks/runs/stream${query ? `?${query}` : \"\"}`);\n    setStatus(\"connecting\");\n    es.onopen = () => setStatus(\"connected\");\n    es.addEventListener(\"runs\", (e) => {\n      try {\n        receive(JSON.parse((e as MessageEvent).data) as TaskRunMeta[]);\n        setStatus(\"connected\");\n      } catch {\n        setStatus(\"invalid task listing data\");\n      }\n    });\n    es.onerror = () => setStatus(\"connection lost — retrying\");\n    return () => es.close();\n  }, [kind, statusFilter, JSON.stringify(labels ?? {}), basePath, enabled, pollMs, forcePoll]);\n\n  return { runs: received.runs, status, runsKey: received.key };\n}\n"],"names":[],"mappings":";;;AAwBA,MAAM,eAAe;AACrB,MAAM,kBAAkB;AAExB,SAAS,UAAU,MAAc,OAAuB;AACtD,SAAO,GAAG,IAAI,gBAAgB,QAAQ,IAAI,KAAK,KAAK,EAAE;AACxD;AAEA,SAAS,iBAA0B;AACjC,SAAO,OAAO,eAAe,eAAe,OAAO,WAAW,gBAAgB;AAChF;AAoBO,SAAS,WAAW,UAA6B,IAAsB;AAC5E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA,WAAW;AAAA,IACX,UAAU;AAAA,IACV,SAAS;AAAA,IACT,YAAY;AAAA,EAAA,IACV;AACJ,QAAM,cAAa,2BAAK,OAAO,cAAa,KAAK,CAAC,EAAE,IAAI,CAAA,IAAK,KAAK,GAAG;AAErE,QAAM,CAAC,MAAM,OAAO,IAAI,SAAuC,CAAA,CAAE;AACjE,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAS,MAAM;AAC3C,QAAM,CAAC,YAAY,aAAa,IAAI,SAAS,KAAK;AAElD,YAAU,MAAM;AACd,UAAM,SAAS,YAAY,UAAU,MAAM,GAAG,IAAI,CAAA;AAClD,QAAI,CAAC,WAAY,OAAO,WAAW,KAAK,CAAC,MAAO;AAC9C,cAAQ,CAAA,CAAE;AACV,gBAAU,MAAM;AAChB,oBAAc,KAAK;AACnB;AAAA,IACF;AACA,YAAQ,CAAA,CAAE;AACV,kBAAc,KAAK;AAEnB,UAAM,SAAS,IAAI,gBAAA;AACnB,QAAI,OAAO,SAAS,EAAG,QAAO,IAAI,SAAS,SAAS;AACpD,QAAI,KAAM,QAAO,IAAI,QAAQ,IAAI;AACjC,UAAM,QAAQ,OAAO,SAAA;AAErB,UAAM,QAAQ,CAAC,aAA6B;AAC1C,cAAQ,CAAC,SAAS;AAChB,cAAM,OAAO,EAAE,GAAG,KAAA;AAClB,mBAAW,QAAQ,SAAU,MAAK,KAAK,SAAS,UAAU,SAAS,KAAK,WAAW,KAAK,EAAE,KAAK,KAAK,EAAE,IAAI;AAC1G,eAAO;AAAA,MACT,CAAC;AAAA,IACH;AAEA,UAAM,cAAc,CAAC,UAMf;AACJ,cAAQ,CAAC,SAAS;AAChB,cAAM,WAAW,KAAK,MAAM,EAAE;AAC9B,YAAI,CAAC,SAAU,QAAO;AACtB,cAAM,QAAQ,MAAM,QAAQ,MAAM,OAAO,GAAG,SAAS,MAAM,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI;AACrF,cAAM,iBAAiB,MAAM,WAAW,WAAW,oBAAoB;AACvE,eAAO;AAAA,UACL,GAAG;AAAA,UACH,CAAC,MAAM,EAAE,GAAG;AAAA,YACV,GAAG;AAAA,YACH,CAAC,MAAM,MAAM,GAAG;AAAA,YAChB,CAAC,cAAc,GAAG,MAAM,aAAa,SAAS,cAAc;AAAA,UAAA;AAAA,QAC9D;AAAA,MAEJ,CAAC;AAAA,IACH;AAGA,QAAI,aAAa,CAAC,kBAAkB;AAClC,UAAI,UAAU;AACd,UAAI;AACJ,YAAM,OAAO,YAAY;AACvB,YAAI;AACF,gBAAM,YAAY,MAAM,QAAQ,IAAI,OAAO,IAAI,CAAC,UAAU;AAAA,YACxD,GAAG,QAAQ,UAAU,mBAAmB,KAAK,CAAC;AAAA,YAC9C,EAAE,SAAS,EAAE,QAAQ,qBAAmB;AAAA,UAAE,CAC3C,CAAC;AACF,cAAI,UAAU,KAAK,CAAC,aAAa,CAAC,SAAS,EAAE,EAAG,OAAM,IAAI,MAAM,qBAAqB;AACrF,cAAI,UAAU,MAAM,CAAC,aAAa,SAAS,EAAE,GAAG;AAC9C,kBAAM,SAAS,MAAM,QAAQ,IAAI,UAAU;AAAA,cACzC,OAAO,aAAc,MAAM,SAAS,KAAA;AAAA,YAAK,CAC1C,GAAG,KAAA;AACJ,gBAAI,QAAS;AACb,kBAAM,KAAK;AACX,sBAAU,SAAS;AACnB,gBAAI,kBAAkB,KAAK,GAAG;AAC5B,4BAAc,IAAI;AAClB;AAAA,YACF;AAAA,UACF;AAAA,QACF,QAAQ;AACN,cAAI,CAAC,QAAS,WAAU,4BAA4B;AAAA,QACtD;AACA,YAAI,CAAC,QAAS,SAAQ,WAAW,MAAM,MAAM;AAAA,MAC/C;AACA,WAAK,KAAA;AACL,aAAO,MAAM;AACX,kBAAU;AACV,YAAI,oBAAoB,KAAK;AAAA,MAC/B;AAAA,IACF;AAGA,UAAM,KAAK,IAAI,YAAY,UAAU,UAAU,KAAK,CAAC;AACrD,cAAU,YAAY;AACtB,OAAG,SAAS,MAAM,UAAU,WAAW;AACvC,OAAG,iBAAiB,QAAQ,CAAC,MAAM;AACjC,UAAI;AACF,cAAM,CAAC,KAAK,MAAO,EAAmB,IAAI,CAAiB,CAAC;AAC5D,kBAAU,WAAW;AAAA,MACvB,QAAQ;AACN,kBAAU,0BAA0B;AAAA,MACtC;AAAA,IACF,CAAC;AACD,OAAG,iBAAiB,UAAU,CAAC,MAAM;AACnC,UAAI;AACF,oBAAY,KAAK,MAAO,EAAmB,IAAI,CAAsC;AAAA,MACvF,QAAQ;AACN,kBAAU,0BAA0B;AAAA,MACtC;AAAA,IACF,CAAC;AACD,OAAG,iBAAiB,QAAQ,MAAM;AAChC,gBAAU,UAAU;AACpB,oBAAc,IAAI;AAClB,SAAG,MAAA;AAAA,IACL,CAAC;AACD,OAAG,UAAU,MAAM,UAAU,4BAA4B;AACzD,WAAO,MAAM,GAAG,MAAA;AAAA,EAClB,GAAG,CAAC,WAAW,MAAM,UAAU,SAAS,QAAQ,SAAS,CAAC;AAE1D,SAAO,EAAE,WAAW,OAAO,OAAO,IAAI,GAAG,QAAQ,WAAA;AACnD;AA+BO,SAAS,YAAY,UAA8B,IAAuB;AAC/E,QAAM;AAAA,IACJ;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,IACA,WAAW;AAAA,IACX,UAAU;AAAA,IACV,SAAS;AAAA,IACT,YAAY;AAAA,EAAA,IACV;AAIJ,QAAM,CAAC,UAAU,WAAW,IAAI,SAG7B,EAAE,KAAK,MAAM,MAAM,CAAA,GAAI;AAC1B,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAS,MAAM;AAE3C,YAAU,MAAM;AACd,QAAI,CAAC,QAAS;AAEd,UAAM,SAAS,IAAI,gBAAA;AACnB,QAAI,KAAM,QAAO,IAAI,QAAQ,IAAI;AACjC,QAAI,aAAc,QAAO,IAAI,UAAU,YAAY;AACnD,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,UAAU,CAAA,CAAE,UAAU,OAAO,SAAS,GAAG,CAAC,IAAI,CAAC,EAAE;AACrF,UAAM,QAAQ,OAAO,SAAA;AACrB,UAAM,aAAa,cAAc,KAAK,EAAE,UAAU,MAAM,QAAQ,cAAc,QAAQ;AACtF,UAAM,UAAU,CAAC,SAAwB,YAAY,EAAE,KAAK,YAAY,MAAM,MAAM;AAGpF,QAAI,aAAa,CAAC,kBAAkB;AAClC,UAAI,UAAU;AACd,UAAI;AACJ,YAAM,OAAO,YAAY;AACvB,YAAI;AACF,gBAAM,MAAM,MAAM,MAAM,GAAG,QAAQ,SAAS,QAAQ,IAAI,KAAK,KAAK,EAAE,IAAI;AAAA,YACtE,SAAS,EAAE,QAAQ,mBAAA;AAAA,UAAmB,CACvC;AACD,cAAI,CAAC,IAAI,GAAI,OAAM,IAAI,MAAM,4BAA4B,IAAI,MAAM,EAAE;AACrE,cAAI,IAAI,IAAI;AACV,kBAAM,OAAQ,MAAM,IAAI,KAAA;AACxB,gBAAI,QAAS;AACb,oBAAQ,IAAI;AACZ,sBAAU,SAAS;AAAA,UACrB;AAAA,QACF,QAAQ;AACN,cAAI,CAAC,QAAS,WAAU,4BAA4B;AAAA,QACtD;AACA,YAAI,CAAC,QAAS,SAAQ,WAAW,MAAM,MAAM;AAAA,MAC/C;AACA,WAAK,KAAA;AACL,aAAO,MAAM;AACX,kBAAU;AACV,YAAI,oBAAoB,KAAK;AAAA,MAC/B;AAAA,IACF;AAGA,UAAM,KAAK,IAAI,YAAY,GAAG,QAAQ,qBAAqB,QAAQ,IAAI,KAAK,KAAK,EAAE,EAAE;AACrF,cAAU,YAAY;AACtB,OAAG,SAAS,MAAM,UAAU,WAAW;AACvC,OAAG,iBAAiB,QAAQ,CAAC,MAAM;AACjC,UAAI;AACF,gBAAQ,KAAK,MAAO,EAAmB,IAAI,CAAkB;AAC7D,kBAAU,WAAW;AAAA,MACvB,QAAQ;AACN,kBAAU,2BAA2B;AAAA,MACvC;AAAA,IACF,CAAC;AACD,OAAG,UAAU,MAAM,UAAU,4BAA4B;AACzD,WAAO,MAAM,GAAG,MAAA;AAAA,EAClB,GAAG,CAAC,MAAM,cAAc,KAAK,UAAU,UAAU,CAAA,CAAE,GAAG,UAAU,SAAS,QAAQ,SAAS,CAAC;AAE3F,SAAO,EAAE,MAAM,SAAS,MAAM,QAAQ,SAAS,SAAS,IAAA;AAC1D;"}

package/dist/hooks/use-theme.d.ts

@@ -6,7 +6,7 @@ export type ThemeContextValue = {
     setTheme: (next: Theme) => void;
 };
 export declare const THEME_STORAGE_KEY = "clicky-ui-theme";
-export declare const ThemeContext: import('../../../../node_modules/@types/react/index.d.ts').Context<ThemeContextValue | null>;
+export declare const ThemeContext: import('react').Context<ThemeContextValue | null>;
 export declare function readStoredTheme(): Theme;
 export declare function resolveTheme(theme: Theme): ResolvedTheme;
 export declare function applyTheme(resolved: ResolvedTheme): void;

package/dist/icons/registry.d.ts

@@ -1,4 +1,4 @@
-import { ComponentType } from '../../../../node_modules/@types/react/index.d.ts';
+import { ComponentType } from 'react';
 import { FallbackIconComponent } from '../data/icon-fallback';
 type NamedIcon = ComponentType<{
     size?: string | number;

package/dist/icons/types.d.ts

@@ -1,4 +1,4 @@
-import { FC, SVGProps } from '../../../../node_modules/@types/react/index.d.ts';
+import { FC, SVGProps } from 'react';
 export type IconProps = Omit<SVGProps<SVGSVGElement>, "color"> & {
     /** Sets width/height. Accepts any CSS length. Defaults to "1em" so the icon scales with surrounding font-size. */
     size?: number | string;

package/dist/index.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const utils = require("./lib/utils.cjs");
+const commentStage = require("./lib/comment-stage.cjs");
 const collections = require("./lib/collections.cjs");
 const palette = require("./lib/palette.cjs");
 const size = require("./lib/size.cjs");
@@ -625,6 +626,9 @@ const useClickyExport = require("./data/clicky-export/useClickyExport.cjs");
 const adapters = require("./data/verification/adapters.cjs");
 const verifyReportTests = require("./data/verification/verifyReportTests.cjs");
 exports.cn = utils.cn;
+exports.resolveCommentStage = commentStage.resolveCommentStage;
+exports.selectCommentThreadsByStage = commentStage.selectCommentThreadsByStage;
+exports.statusForCommentStage = commentStage.statusForCommentStage;
 exports.duplicateIndex = collections.duplicateIndex;
 exports.isPlainObject = collections.isPlainObject;
 exports.moveItem = collections.moveItem;
@@ -1054,14 +1058,11 @@ exports.hasActiveFilters = commentUtils.hasActiveFilters;
 exports.isUnresolved = commentUtils.isUnresolved;
 exports.matchMentionsInBody = commentUtils.matchMentionsInBody;
 exports.nextChecklistStatus = commentUtils.nextChecklistStatus;
-exports.resolveCommentStage = commentUtils.resolveCommentStage;
 exports.resolveFacetOption = commentUtils.resolveFacetOption;
 exports.resolveStatusConfig = commentUtils.resolveStatusConfig;
 exports.selectAnchorThreads = commentUtils.selectAnchorThreads;
-exports.selectCommentThreadsByStage = commentUtils.selectCommentThreadsByStage;
 exports.selectUnresolvedThreads = commentUtils.selectUnresolvedThreads;
 exports.sortReplies = commentUtils.sortReplies;
-exports.statusForCommentStage = commentUtils.statusForCommentStage;
 exports.toneToBadgeTone = commentUtils.toneToBadgeTone;
 exports.truncatePlain = commentUtils.truncatePlain;
 exports.CommentMarkdown = CommentMarkdown.CommentMarkdown;

package/dist/index.cjs.map

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

package/dist/index.js

@@ -1,4 +1,5 @@
 import { cn } from "./lib/utils.js";
+import { resolveCommentStage, selectCommentThreadsByStage, statusForCommentStage } from "./lib/comment-stage.js";
 import { duplicateIndex, isPlainObject, moveItem, removeIndex, setIndex } from "./lib/collections.js";
 import { AVATAR_PALETTE, fnv1a32, paletteClass } from "./lib/palette.js";
 import { SIZE_TOKENS, resolveSize } from "./lib/size.js";
@@ -212,7 +213,7 @@ import { CopyBadge, ErrorDetails, PrettyStackTrace } from "./data/diagnostics/Er
 import { compactStackPath, isApplicationStackFrame, normalizeErrorDiagnostics, parseDiagnosticsStackTrace, parseInlineJsonContextValue } from "./data/diagnostics/error-diagnostics.js";
 import { HarPanel } from "./data/har/HarPanel.js";
 import { DEFAULT_CHECKLIST_CYCLE, DEFAULT_COMMENT_STATUSES, DOCUMENT_ANCHOR } from "./comments/comment-types.js";
-import { applyCommentFilters, authorDisplayName, buildReplyMap, buildThreadListHandlers, commentCountForPrefix, defaultStatusValue, deriveAnchorCounts, deriveAnchorMeta, emptyCommentFilters, getRoots, groupByFacet, hasActiveFilters, isUnresolved, matchMentionsInBody, nextChecklistStatus, resolveCommentStage, resolveFacetOption, resolveStatusConfig, selectAnchorThreads, selectCommentThreadsByStage, selectUnresolvedThreads, sortReplies, statusForCommentStage, toneToBadgeTone, truncatePlain } from "./comments/comment-utils.js";
+import { applyCommentFilters, authorDisplayName, buildReplyMap, buildThreadListHandlers, commentCountForPrefix, defaultStatusValue, deriveAnchorCounts, deriveAnchorMeta, emptyCommentFilters, getRoots, groupByFacet, hasActiveFilters, isUnresolved, matchMentionsInBody, nextChecklistStatus, resolveFacetOption, resolveStatusConfig, selectAnchorThreads, selectUnresolvedThreads, sortReplies, toneToBadgeTone, truncatePlain } from "./comments/comment-utils.js";
 import { CommentMarkdown } from "./comments/CommentMarkdown.js";
 import { CommentAuthorAvatar } from "./comments/CommentAuthor.js";
 import { MentionTextarea } from "./comments/MentionTextarea.js";

package/dist/index.js.map

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

package/dist/layout/AppShell.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { StaticIconComponent } from '../data/Icon';
 import { DropdownMenuItem } from '../overlay/DropdownMenu';
 import { AppShellNavDrag } from './AppShell.nav.drag';

package/dist/layout/AppShell.nav.drag.d.ts

@@ -1,4 +1,4 @@
-import { HTMLAttributes } from '../../../../node_modules/@types/react/index.d.ts';
+import { HTMLAttributes } from 'react';
 /** Which kind of nav row a drag endpoint is. */
 export type AppShellNavDropKind = "item" | "group" | "section";
 /** One end of a drag: a row's `key` plus what that row is. */

package/dist/layout/AppSidebar.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { RenderLink } from '../rpc/EndpointList';
 import { ContentWidth } from './content-width';
 export interface AppNavItem {

package/dist/layout/Panel.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { StaticIconComponent } from '../data/Icon';
 import { PanelTone } from './PanelFrame';
 export type { PanelTone } from './PanelFrame';

package/dist/layout/PanelFrame.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 export type PanelTone = "default" | "danger" | "warning" | "success" | "info";
 export type PanelFrameProps = {
     header?: ReactNode;

package/dist/layout/Section.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { StaticIconComponent } from '../data/Icon';
 import { PanelTone } from './PanelFrame';
 export type SectionProps = {

package/dist/layout/SplitPane.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 export type SplitPaneProps = {
     /** Content rendered in the left pane. */
     left: ReactNode;

package/dist/layout/Tabs.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { TabButtonVariant } from '../data/TabButton';
 import { StaticIconComponent } from '../data/Icon';
 export type TabItem = {

package/dist/layout/Workspace.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { WorkspaceLayoutDefaults, WorkspaceLayoutState, WorkspacePaneSpec } from './Workspace.model';
 export type { WorkspaceLayoutDefaults, WorkspaceLayoutState, WorkspacePaneLocation, WorkspacePaneSlots, WorkspacePaneSpec, WorkspaceSideLocation, } from './Workspace.model';
 export type WorkspaceSlots = {

package/dist/layout/Workspace.model.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 export type WorkspacePaneLocation = "left" | "center" | "right" | "bottom";
 export type WorkspaceSideLocation = "left" | "right";
 export type WorkspacePaneSlots = {

package/dist/lib/combobox-values.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties, ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { CSSProperties, ReactNode } from 'react';
 import { ComboboxOption } from '../components/combobox-types';
 export declare function comboboxLabelPadding(label: ReactNode, measuredWidth: number): CSSProperties;
 export declare function withSelectedComboboxOptions(options: ComboboxOption[], selectedValues: string[]): ComboboxOption[];

package/dist/lib/comment-stage.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commentUtils = require("../comments/comment-utils.cjs");
+function resolveCommentStage(config, status) {
+  if (status == null) return "active";
+  const resolved = commentUtils.resolveStatusConfig(config, status);
+  if (!resolved) return void 0;
+  if (resolved.stage) return resolved.stage;
+  if (resolved.unresolved) return "active";
+  if (resolved.value.toLowerCase() === "closed" || resolved.label.toLowerCase() === "closed") {
+    return "closed";
+  }
+  return "resolved";
+}
+function statusForCommentStage(config, stage) {
+  return config.statuses.find(
+    (status) => resolveCommentStage(config, status.value) === stage
+  );
+}
+function selectCommentThreadsByStage(comments, config, stage) {
+  const keep = new Set(
+    commentUtils.getRoots(comments).filter((root) => resolveCommentStage(config, root.status) === stage).map((root) => String(root.id))
+  );
+  return comments.filter(
+    (comment) => keep.has(String(comment.parentId ?? comment.id))
+  );
+}
+exports.resolveCommentStage = resolveCommentStage;
+exports.selectCommentThreadsByStage = selectCommentThreadsByStage;
+exports.statusForCommentStage = statusForCommentStage;
+//# sourceMappingURL=comment-stage.cjs.map

package/dist/lib/comment-stage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-stage.cjs","sources":["../../src/lib/comment-stage.ts"],"sourcesContent":["import type {\n  Comment,\n  CommentConfig,\n  CommentStatusConfig,\n  CommentStatusStage,\n} from \"../comments/comment-types\";\nimport { getRoots, resolveStatusConfig } from \"../comments/comment-utils\";\n\n/** Resolves a stored status to its lifecycle stage. */\nexport function resolveCommentStage(\n  config: CommentConfig,\n  status: string | undefined,\n): CommentStatusStage | undefined {\n  if (status == null) return \"active\";\n  const resolved = resolveStatusConfig(config, status);\n  if (!resolved) return undefined;\n  if (resolved.stage) return resolved.stage;\n  if (resolved.unresolved) return \"active\";\n  if (\n    resolved.value.toLowerCase() === \"closed\" ||\n    resolved.label.toLowerCase() === \"closed\"\n  ) {\n    return \"closed\";\n  }\n  return \"resolved\";\n}\n\n/** Returns the first configured stored status for a lifecycle stage. */\nexport function statusForCommentStage(\n  config: CommentConfig,\n  stage: CommentStatusStage,\n): CommentStatusConfig | undefined {\n  return config.statuses.find(\n    (status) => resolveCommentStage(config, status.value) === stage,\n  );\n}\n\n/** Selects roots in one lifecycle stage together with every descendant reply. */\nexport function selectCommentThreadsByStage(\n  comments: Comment[],\n  config: CommentConfig,\n  stage: CommentStatusStage,\n): Comment[] {\n  const keep = new Set(\n    getRoots(comments)\n      .filter((root) => resolveCommentStage(config, root.status) === stage)\n      .map((root) => String(root.id)),\n  );\n  return comments.filter((comment) =>\n    keep.has(String(comment.parentId ?? comment.id)),\n  );\n}\n"],"names":["resolveStatusConfig","getRoots"],"mappings":";;;AASO,SAAS,oBACd,QACA,QACgC;AAChC,MAAI,UAAU,KAAM,QAAO;AAC3B,QAAM,WAAWA,aAAAA,oBAAoB,QAAQ,MAAM;AACnD,MAAI,CAAC,SAAU,QAAO;AACtB,MAAI,SAAS,MAAO,QAAO,SAAS;AACpC,MAAI,SAAS,WAAY,QAAO;AAChC,MACE,SAAS,MAAM,kBAAkB,YACjC,SAAS,MAAM,YAAA,MAAkB,UACjC;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAGO,SAAS,sBACd,QACA,OACiC;AACjC,SAAO,OAAO,SAAS;AAAA,IACrB,CAAC,WAAW,oBAAoB,QAAQ,OAAO,KAAK,MAAM;AAAA,EAAA;AAE9D;AAGO,SAAS,4BACd,UACA,QACA,OACW;AACX,QAAM,OAAO,IAAI;AAAA,IACfC,aAAAA,SAAS,QAAQ,EACd,OAAO,CAAC,SAAS,oBAAoB,QAAQ,KAAK,MAAM,MAAM,KAAK,EACnE,IAAI,CAAC,SAAS,OAAO,KAAK,EAAE,CAAC;AAAA,EAAA;AAElC,SAAO,SAAS;AAAA,IAAO,CAAC,YACtB,KAAK,IAAI,OAAO,QAAQ,YAAY,QAAQ,EAAE,CAAC;AAAA,EAAA;AAEnD;;;;"}

package/dist/lib/comment-stage.d.ts

@@ -0,0 +1,8 @@
+import { Comment, CommentConfig, CommentStatusConfig, CommentStatusStage } from '../comments/comment-types';
+/** Resolves a stored status to its lifecycle stage. */
+export declare function resolveCommentStage(config: CommentConfig, status: string | undefined): CommentStatusStage | undefined;
+/** Returns the first configured stored status for a lifecycle stage. */
+export declare function statusForCommentStage(config: CommentConfig, stage: CommentStatusStage): CommentStatusConfig | undefined;
+/** Selects roots in one lifecycle stage together with every descendant reply. */
+export declare function selectCommentThreadsByStage(comments: Comment[], config: CommentConfig, stage: CommentStatusStage): Comment[];
+//# sourceMappingURL=comment-stage.d.ts.map

package/dist/lib/comment-stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-stage.d.ts","sourceRoot":"","sources":["../../src/lib/comment-stage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,2BAA2B,CAAC;AAGnC,uDAAuD;AACvD,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,kBAAkB,GAAG,SAAS,CAahC;AAED,wEAAwE;AACxE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,kBAAkB,GACxB,mBAAmB,GAAG,SAAS,CAIjC;AAED,iFAAiF;AACjF,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EAAE,EACnB,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,kBAAkB,GACxB,OAAO,EAAE,CASX"}

package/dist/lib/comment-stage.js

@@ -0,0 +1,31 @@
+import { resolveStatusConfig, getRoots } from "../comments/comment-utils.js";
+function resolveCommentStage(config, status) {
+  if (status == null) return "active";
+  const resolved = resolveStatusConfig(config, status);
+  if (!resolved) return void 0;
+  if (resolved.stage) return resolved.stage;
+  if (resolved.unresolved) return "active";
+  if (resolved.value.toLowerCase() === "closed" || resolved.label.toLowerCase() === "closed") {
+    return "closed";
+  }
+  return "resolved";
+}
+function statusForCommentStage(config, stage) {
+  return config.statuses.find(
+    (status) => resolveCommentStage(config, status.value) === stage
+  );
+}
+function selectCommentThreadsByStage(comments, config, stage) {
+  const keep = new Set(
+    getRoots(comments).filter((root) => resolveCommentStage(config, root.status) === stage).map((root) => String(root.id))
+  );
+  return comments.filter(
+    (comment) => keep.has(String(comment.parentId ?? comment.id))
+  );
+}
+export {
+  resolveCommentStage,
+  selectCommentThreadsByStage,
+  statusForCommentStage
+};
+//# sourceMappingURL=comment-stage.js.map

package/dist/lib/comment-stage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-stage.js","sources":["../../src/lib/comment-stage.ts"],"sourcesContent":["import type {\n  Comment,\n  CommentConfig,\n  CommentStatusConfig,\n  CommentStatusStage,\n} from \"../comments/comment-types\";\nimport { getRoots, resolveStatusConfig } from \"../comments/comment-utils\";\n\n/** Resolves a stored status to its lifecycle stage. */\nexport function resolveCommentStage(\n  config: CommentConfig,\n  status: string | undefined,\n): CommentStatusStage | undefined {\n  if (status == null) return \"active\";\n  const resolved = resolveStatusConfig(config, status);\n  if (!resolved) return undefined;\n  if (resolved.stage) return resolved.stage;\n  if (resolved.unresolved) return \"active\";\n  if (\n    resolved.value.toLowerCase() === \"closed\" ||\n    resolved.label.toLowerCase() === \"closed\"\n  ) {\n    return \"closed\";\n  }\n  return \"resolved\";\n}\n\n/** Returns the first configured stored status for a lifecycle stage. */\nexport function statusForCommentStage(\n  config: CommentConfig,\n  stage: CommentStatusStage,\n): CommentStatusConfig | undefined {\n  return config.statuses.find(\n    (status) => resolveCommentStage(config, status.value) === stage,\n  );\n}\n\n/** Selects roots in one lifecycle stage together with every descendant reply. */\nexport function selectCommentThreadsByStage(\n  comments: Comment[],\n  config: CommentConfig,\n  stage: CommentStatusStage,\n): Comment[] {\n  const keep = new Set(\n    getRoots(comments)\n      .filter((root) => resolveCommentStage(config, root.status) === stage)\n      .map((root) => String(root.id)),\n  );\n  return comments.filter((comment) =>\n    keep.has(String(comment.parentId ?? comment.id)),\n  );\n}\n"],"names":[],"mappings":";AASO,SAAS,oBACd,QACA,QACgC;AAChC,MAAI,UAAU,KAAM,QAAO;AAC3B,QAAM,WAAW,oBAAoB,QAAQ,MAAM;AACnD,MAAI,CAAC,SAAU,QAAO;AACtB,MAAI,SAAS,MAAO,QAAO,SAAS;AACpC,MAAI,SAAS,WAAY,QAAO;AAChC,MACE,SAAS,MAAM,kBAAkB,YACjC,SAAS,MAAM,YAAA,MAAkB,UACjC;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAGO,SAAS,sBACd,QACA,OACiC;AACjC,SAAO,OAAO,SAAS;AAAA,IACrB,CAAC,WAAW,oBAAoB,QAAQ,OAAO,KAAK,MAAM;AAAA,EAAA;AAE9D;AAGO,SAAS,4BACd,UACA,QACA,OACW;AACX,QAAM,OAAO,IAAI;AAAA,IACf,SAAS,QAAQ,EACd,OAAO,CAAC,SAAS,oBAAoB,QAAQ,KAAK,MAAM,MAAM,KAAK,EACnE,IAAI,CAAC,SAAS,OAAO,KAAK,EAAE,CAAC;AAAA,EAAA;AAElC,SAAO,SAAS;AAAA,IAAO,CAAC,YACtB,KAAK,IAAI,OAAO,QAAQ,YAAY,QAAQ,EAAE,CAAC;AAAA,EAAA;AAEnD;"}

package/dist/monaco/MonacoEditor.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const jsxRuntime = require("react/jsx-runtime");
 const Editor = require("@monaco-editor/react");
-const monaco = require("monaco-editor");
+const monacoEditor = require("monaco-editor");
 const useTheme = require("../hooks/use-theme.cjs");
 const useMonacoWorker = require("./use-monaco-worker.cjs");
 function _interopNamespaceDefault(e) {
@@ -21,8 +21,8 @@ function _interopNamespaceDefault(e) {
   n.default = e;
   return Object.freeze(n);
 }
-const monaco__namespace = /* @__PURE__ */ _interopNamespaceDefault(monaco);
-Editor.loader.config({ monaco: monaco__namespace });
+const monacoEditor__namespace = /* @__PURE__ */ _interopNamespaceDefault(monacoEditor);
+Editor.loader.config({ monaco: monacoEditor__namespace });
 function MonacoEditor({
   value,
   onChange,

package/dist/monaco/MonacoEditor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"MonacoEditor.cjs","sources":["../../src/monaco/MonacoEditor.tsx"],"sourcesContent":["import Editor, { loader, type Monaco } from \"@monaco-editor/react\";\nimport * as monaco from \"monaco-editor\";\nimport { useResolvedTheme } from \"../hooks/use-theme\";\nimport { useMonacoWorkerFactory } from \"./use-monaco-worker\";\nimport type { MonacoEditorProps } from \"./types\";\n\nloader.config({ monaco });\n\nexport function MonacoEditor({\n  value,\n  onChange,\n  language,\n  path,\n  height = \"20rem\",\n  beforeMount,\n  onMount,\n  onValidate,\n}: MonacoEditorProps) {\n  const workers = useMonacoWorkerFactory();\n  const theme = useResolvedTheme() === \"dark\" ? \"vs-dark\" : \"light\";\n\n  if (!workers) {\n    return <div role=\"alert\" className=\"rounded-md border border-destructive/40 p-3 text-sm text-destructive\">Monaco workers are not configured.</div>;\n  }\n\n  return (\n    <div className=\"overflow-hidden rounded-md border border-input\" data-slot=\"monaco-editor\">\n      <Editor\n        value={value}\n        onChange={(next) => onChange(next ?? \"\")}\n        language={language}\n        path={path}\n        height={height}\n        theme={theme}\n        keepCurrentModel\n        {...(beforeMount ? { beforeMount } : {})}\n        {...(onMount\n          ? { onMount: (instance, monacoInstance) => onMount(instance, monacoInstance) }\n          : {})}\n        {...(onValidate ? { onValidate } : {})}\n        options={{\n          automaticLayout: true,\n          fontFamily: \"var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)\",\n          fontSize: 13,\n          lineHeight: 20,\n          minimap: { enabled: false },\n          scrollBeyondLastLine: false,\n          tabSize: 2,\n          wordWrap: \"on\",\n          quickSuggestions: { other: true, comments: true, strings: true },\n        }}\n      />\n    </div>\n  );\n}\n\nexport type { Monaco };\n"],"names":["loader","monaco","useMonacoWorkerFactory","useResolvedTheme","jsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAMAA,OAAAA,OAAO,OAAO,EAAA,QAAEC,mBAAQ;AAEjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,QAAM,UAAUC,gBAAAA,uBAAA;AAChB,QAAM,QAAQC,SAAAA,iBAAA,MAAuB,SAAS,YAAY;AAE1D,MAAI,CAAC,SAAS;AACZ,0CAAQ,OAAA,EAAI,MAAK,SAAQ,WAAU,wEAAuE,UAAA,sCAAkC;AAAA,EAC9I;AAEA,SACEC,2BAAAA,IAAC,OAAA,EAAI,WAAU,kDAAiD,aAAU,iBACxE,UAAAA,2BAAAA;AAAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,UAAU,CAAC,SAAS,SAAS,QAAQ,EAAE;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAgB;AAAA,MACf,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,MACpC,GAAI,UACD,EAAE,SAAS,CAAC,UAAU,mBAAmB,QAAQ,UAAU,cAAc,EAAA,IACzE,CAAA;AAAA,MACH,GAAI,aAAa,EAAE,WAAA,IAAe,CAAA;AAAA,MACnC,SAAS;AAAA,QACP,iBAAiB;AAAA,QACjB,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,SAAS,EAAE,SAAS,MAAA;AAAA,QACpB,sBAAsB;AAAA,QACtB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,kBAAkB,EAAE,OAAO,MAAM,UAAU,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACjE;AAAA,EAAA,GAEJ;AAEJ;;"}
+{"version":3,"file":"MonacoEditor.cjs","sources":["../../src/monaco/MonacoEditor.tsx"],"sourcesContent":["import Editor, { loader, type Monaco } from \"@monaco-editor/react\";\nimport * as monaco from \"monaco-editor\";\nimport { useResolvedTheme } from \"../hooks/use-theme\";\nimport { useMonacoWorkerFactory } from \"./use-monaco-worker\";\nimport type { MonacoEditorProps } from \"./types\";\n\nloader.config({ monaco });\n\nexport function MonacoEditor({\n  value,\n  onChange,\n  language,\n  path,\n  height = \"20rem\",\n  beforeMount,\n  onMount,\n  onValidate,\n}: MonacoEditorProps) {\n  const workers = useMonacoWorkerFactory();\n  const theme = useResolvedTheme() === \"dark\" ? \"vs-dark\" : \"light\";\n\n  if (!workers) {\n    return <div role=\"alert\" className=\"rounded-md border border-destructive/40 p-3 text-sm text-destructive\">Monaco workers are not configured.</div>;\n  }\n\n  return (\n    <div className=\"overflow-hidden rounded-md border border-input\" data-slot=\"monaco-editor\">\n      <Editor\n        value={value}\n        onChange={(next) => onChange(next ?? \"\")}\n        language={language}\n        path={path}\n        height={height}\n        theme={theme}\n        keepCurrentModel\n        {...(beforeMount ? { beforeMount } : {})}\n        {...(onMount\n          ? { onMount: (instance, monacoInstance) => onMount(instance, monacoInstance) }\n          : {})}\n        {...(onValidate ? { onValidate } : {})}\n        options={{\n          automaticLayout: true,\n          fontFamily: \"var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)\",\n          fontSize: 13,\n          lineHeight: 20,\n          minimap: { enabled: false },\n          scrollBeyondLastLine: false,\n          tabSize: 2,\n          wordWrap: \"on\",\n          quickSuggestions: { other: true, comments: true, strings: true },\n        }}\n      />\n    </div>\n  );\n}\n\nexport type { Monaco };\n"],"names":["loader","monaco","useMonacoWorkerFactory","useResolvedTheme","jsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAMAA,OAAAA,OAAO,OAAO,EAAA,QAAEC,yBAAQ;AAEjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,QAAM,UAAUC,gBAAAA,uBAAA;AAChB,QAAM,QAAQC,SAAAA,iBAAA,MAAuB,SAAS,YAAY;AAE1D,MAAI,CAAC,SAAS;AACZ,0CAAQ,OAAA,EAAI,MAAK,SAAQ,WAAU,wEAAuE,UAAA,sCAAkC;AAAA,EAC9I;AAEA,SACEC,2BAAAA,IAAC,OAAA,EAAI,WAAU,kDAAiD,aAAU,iBACxE,UAAAA,2BAAAA;AAAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,UAAU,CAAC,SAAS,SAAS,QAAQ,EAAE;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAgB;AAAA,MACf,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,MACpC,GAAI,UACD,EAAE,SAAS,CAAC,UAAU,mBAAmB,QAAQ,UAAU,cAAc,EAAA,IACzE,CAAA;AAAA,MACH,GAAI,aAAa,EAAE,WAAA,IAAe,CAAA;AAAA,MACnC,SAAS;AAAA,QACP,iBAAiB;AAAA,QACjB,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,SAAS,EAAE,SAAS,MAAA;AAAA,QACpB,sBAAsB;AAAA,QACtB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,kBAAkB,EAAE,OAAO,MAAM,UAAU,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACjE;AAAA,EAAA,GAEJ;AAEJ;;"}

package/dist/monaco/MonacoEditor.js

@@ -1,9 +1,9 @@
 import { jsx } from "react/jsx-runtime";
 import Editor, { loader } from "@monaco-editor/react";
-import * as monaco from "monaco-editor";
+import * as monacoEditor from "monaco-editor";
 import { useResolvedTheme } from "../hooks/use-theme.js";
 import { useMonacoWorkerFactory } from "./use-monaco-worker.js";
-loader.config({ monaco });
+loader.config({ monaco: monacoEditor });
 function MonacoEditor({
   value,
   onChange,

package/dist/monaco/MonacoEditor.js.map

@@ -1 +1 @@
-{"version":3,"file":"MonacoEditor.js","sources":["../../src/monaco/MonacoEditor.tsx"],"sourcesContent":["import Editor, { loader, type Monaco } from \"@monaco-editor/react\";\nimport * as monaco from \"monaco-editor\";\nimport { useResolvedTheme } from \"../hooks/use-theme\";\nimport { useMonacoWorkerFactory } from \"./use-monaco-worker\";\nimport type { MonacoEditorProps } from \"./types\";\n\nloader.config({ monaco });\n\nexport function MonacoEditor({\n  value,\n  onChange,\n  language,\n  path,\n  height = \"20rem\",\n  beforeMount,\n  onMount,\n  onValidate,\n}: MonacoEditorProps) {\n  const workers = useMonacoWorkerFactory();\n  const theme = useResolvedTheme() === \"dark\" ? \"vs-dark\" : \"light\";\n\n  if (!workers) {\n    return <div role=\"alert\" className=\"rounded-md border border-destructive/40 p-3 text-sm text-destructive\">Monaco workers are not configured.</div>;\n  }\n\n  return (\n    <div className=\"overflow-hidden rounded-md border border-input\" data-slot=\"monaco-editor\">\n      <Editor\n        value={value}\n        onChange={(next) => onChange(next ?? \"\")}\n        language={language}\n        path={path}\n        height={height}\n        theme={theme}\n        keepCurrentModel\n        {...(beforeMount ? { beforeMount } : {})}\n        {...(onMount\n          ? { onMount: (instance, monacoInstance) => onMount(instance, monacoInstance) }\n          : {})}\n        {...(onValidate ? { onValidate } : {})}\n        options={{\n          automaticLayout: true,\n          fontFamily: \"var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)\",\n          fontSize: 13,\n          lineHeight: 20,\n          minimap: { enabled: false },\n          scrollBeyondLastLine: false,\n          tabSize: 2,\n          wordWrap: \"on\",\n          quickSuggestions: { other: true, comments: true, strings: true },\n        }}\n      />\n    </div>\n  );\n}\n\nexport type { Monaco };\n"],"names":[],"mappings":";;;;;AAMA,OAAO,OAAO,EAAE,QAAQ;AAEjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,QAAM,UAAU,uBAAA;AAChB,QAAM,QAAQ,iBAAA,MAAuB,SAAS,YAAY;AAE1D,MAAI,CAAC,SAAS;AACZ,+BAAQ,OAAA,EAAI,MAAK,SAAQ,WAAU,wEAAuE,UAAA,sCAAkC;AAAA,EAC9I;AAEA,SACE,oBAAC,OAAA,EAAI,WAAU,kDAAiD,aAAU,iBACxE,UAAA;AAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,UAAU,CAAC,SAAS,SAAS,QAAQ,EAAE;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAgB;AAAA,MACf,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,MACpC,GAAI,UACD,EAAE,SAAS,CAAC,UAAU,mBAAmB,QAAQ,UAAU,cAAc,EAAA,IACzE,CAAA;AAAA,MACH,GAAI,aAAa,EAAE,WAAA,IAAe,CAAA;AAAA,MACnC,SAAS;AAAA,QACP,iBAAiB;AAAA,QACjB,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,SAAS,EAAE,SAAS,MAAA;AAAA,QACpB,sBAAsB;AAAA,QACtB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,kBAAkB,EAAE,OAAO,MAAM,UAAU,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACjE;AAAA,EAAA,GAEJ;AAEJ;"}
+{"version":3,"file":"MonacoEditor.js","sources":["../../src/monaco/MonacoEditor.tsx"],"sourcesContent":["import Editor, { loader, type Monaco } from \"@monaco-editor/react\";\nimport * as monaco from \"monaco-editor\";\nimport { useResolvedTheme } from \"../hooks/use-theme\";\nimport { useMonacoWorkerFactory } from \"./use-monaco-worker\";\nimport type { MonacoEditorProps } from \"./types\";\n\nloader.config({ monaco });\n\nexport function MonacoEditor({\n  value,\n  onChange,\n  language,\n  path,\n  height = \"20rem\",\n  beforeMount,\n  onMount,\n  onValidate,\n}: MonacoEditorProps) {\n  const workers = useMonacoWorkerFactory();\n  const theme = useResolvedTheme() === \"dark\" ? \"vs-dark\" : \"light\";\n\n  if (!workers) {\n    return <div role=\"alert\" className=\"rounded-md border border-destructive/40 p-3 text-sm text-destructive\">Monaco workers are not configured.</div>;\n  }\n\n  return (\n    <div className=\"overflow-hidden rounded-md border border-input\" data-slot=\"monaco-editor\">\n      <Editor\n        value={value}\n        onChange={(next) => onChange(next ?? \"\")}\n        language={language}\n        path={path}\n        height={height}\n        theme={theme}\n        keepCurrentModel\n        {...(beforeMount ? { beforeMount } : {})}\n        {...(onMount\n          ? { onMount: (instance, monacoInstance) => onMount(instance, monacoInstance) }\n          : {})}\n        {...(onValidate ? { onValidate } : {})}\n        options={{\n          automaticLayout: true,\n          fontFamily: \"var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)\",\n          fontSize: 13,\n          lineHeight: 20,\n          minimap: { enabled: false },\n          scrollBeyondLastLine: false,\n          tabSize: 2,\n          wordWrap: \"on\",\n          quickSuggestions: { other: true, comments: true, strings: true },\n        }}\n      />\n    </div>\n  );\n}\n\nexport type { Monaco };\n"],"names":["monaco"],"mappings":";;;;;AAMA,OAAO,OAAO,EAAA,QAAEA,cAAQ;AAEjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,QAAM,UAAU,uBAAA;AAChB,QAAM,QAAQ,iBAAA,MAAuB,SAAS,YAAY;AAE1D,MAAI,CAAC,SAAS;AACZ,+BAAQ,OAAA,EAAI,MAAK,SAAQ,WAAU,wEAAuE,UAAA,sCAAkC;AAAA,EAC9I;AAEA,SACE,oBAAC,OAAA,EAAI,WAAU,kDAAiD,aAAU,iBACxE,UAAA;AAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,UAAU,CAAC,SAAS,SAAS,QAAQ,EAAE;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAgB;AAAA,MACf,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,MACpC,GAAI,UACD,EAAE,SAAS,CAAC,UAAU,mBAAmB,QAAQ,UAAU,cAAc,EAAA,IACzE,CAAA;AAAA,MACH,GAAI,aAAa,EAAE,WAAA,IAAe,CAAA;AAAA,MACnC,SAAS;AAAA,QACP,iBAAiB;AAAA,QACjB,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,SAAS,EAAE,SAAS,MAAA;AAAA,QACpB,sBAAsB;AAAA,QACtB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,kBAAkB,EAAE,OAAO,MAAM,UAAU,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACjE;AAAA,EAAA,GAEJ;AAEJ;"}

package/dist/monaco/types.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { editor } from 'monaco-editor';
 import { Monaco } from '@monaco-editor/react';
 import { JsonSchemaObject } from '../components/json-schema-form-types';

package/dist/monaco/use-monaco-worker.d.ts

@@ -1,4 +1,4 @@
 import { MonacoWorkerFactory } from './types';
-export declare const WorkerContext: import('../../../../node_modules/@types/react/index.d.ts').Context<MonacoWorkerFactory | null>;
+export declare const WorkerContext: import('react').Context<MonacoWorkerFactory | null>;
 export declare function useMonacoWorkerFactory(): MonacoWorkerFactory | null;
 //# sourceMappingURL=use-monaco-worker.d.ts.map

package/dist/overlay/CellActions.d.ts

@@ -1,4 +1,4 @@
-import { ButtonHTMLAttributes, ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ButtonHTMLAttributes, ReactNode } from 'react';
 import { StaticIconComponent } from '../data/Icon';
 import { DropdownMenuItem } from './DropdownMenu';
 export type CellActionsProps = {

package/dist/overlay/CommandPalette.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { CommandFilter, CommandGroup, CommandItem } from './CommandPalette.model';
 export type { CommandFilter, CommandGroup, CommandItem, CommandSelectContext, } from './CommandPalette.model';
 export type CommandPaletteProps = {
@@ -67,5 +67,5 @@ export type CommandPaletteProps = {
  * `zIndex` scale), so a palette opened over a modal sits above it and Escape
  * still dismisses exactly one layer.
  */
-export declare function CommandPalette({ open, onOpenChange, groups, query, onQueryChange, hotkey, placeholder, loading, emptyState, footer, filter, onSelect, closeOnSelect, resetQueryOnClose, size, topOffset, listMaxHeight, ariaLabel, className, }: CommandPaletteProps): import('../../../../node_modules/@types/react/index.d.ts').ReactPortal | null;
+export declare function CommandPalette({ open, onOpenChange, groups, query, onQueryChange, hotkey, placeholder, loading, emptyState, footer, filter, onSelect, closeOnSelect, resetQueryOnClose, size, topOffset, listMaxHeight, ariaLabel, className, }: CommandPaletteProps): import('react').ReactPortal | null;
 //# sourceMappingURL=CommandPalette.d.ts.map

package/dist/overlay/CommandPalette.model.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { StaticIconComponent } from '../data/Icon';
 /** Context handed to a command's `onSelect`. */
 export type CommandSelectContext = {

package/dist/overlay/CommandPaletteList.d.ts

@@ -1,4 +1,4 @@
-import { RefObject } from '../../../../node_modules/@types/react/index.d.ts';
+import { RefObject } from 'react';
 import { CommandGroup, CommandItem } from './CommandPalette.model';
 export type CommandPaletteListProps = {
     groups: CommandGroup[];

package/dist/overlay/DropdownMenu.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { ButtonProps } from '../components/button';
 import { StaticIconComponent } from '../data/Icon';
 export type DropdownMenuItem = {

package/dist/overlay/HoverCard.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 export type HoverCardPlacement = "top" | "bottom" | "left" | "right";
 export type HoverCardProps = {
     /** Trigger content that opens the card on hover/focus. */

package/dist/overlay/Modal.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 export type ModalSize = "sm" | "md" | "lg" | "xl" | "2xl" | "full";
 /** Copy for the discard-confirmation prompt shown before a guarded close. */
 export type ConfirmCloseOptions = {
@@ -57,5 +57,5 @@ export type ModalProps = {
     /** Modal body content. */
     children: ReactNode;
 };
-export declare function Modal({ open, onClose, confirmClose, title, subtitle, size, closeOnBackdrop, closeOnEsc, hideClose, expandable, className, headerSlot, footer, scrollBody, children, }: ModalProps): import('../../../../node_modules/@types/react/index.d.ts').ReactPortal | null;
+export declare function Modal({ open, onClose, confirmClose, title, subtitle, size, closeOnBackdrop, closeOnEsc, hideClose, expandable, className, headerSlot, footer, scrollBody, children, }: ModalProps): import('react').ReactPortal | null;
 //# sourceMappingURL=Modal.d.ts.map

package/dist/overlay/Toast.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 export type ToastProviderProps = {
     children: ReactNode;
     /** Default auto-dismiss delay applied when a toast omits `durationMs`. */

package/dist/overlay/TourCard.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { TourLabels, TourStep } from './tour-types';
 export type TourCardProps = {
     step: TourStep;

package/dist/overlay/TourProvider.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { TourProps } from './Tour';
 import { TourCompletionStatus, TourStorage } from './tour-progress';
 import { TourDefinition, TourStepContext } from './tour-types';

package/dist/overlay/dropdownMenuContext.d.ts

@@ -12,5 +12,5 @@ export type MenuContextValue = {
     setHasFocusInside: (value: boolean) => void;
     isOpen: boolean;
 };
-export declare const MenuContext: import('../../../../node_modules/@types/react/index.d.ts').Context<MenuContextValue>;
+export declare const MenuContext: import('react').Context<MenuContextValue>;
 //# sourceMappingURL=dropdownMenuContext.d.ts.map

package/dist/overlay/toast-context.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { BadgeTone } from '../data/Badge';
 export type ToastTone = BadgeTone;
 export type ToastOptions = {
@@ -18,7 +18,7 @@ export type ToastContextValue = {
     /** Dismiss a toast by id. */
     dismiss: (id: number) => void;
 };
-export declare const ToastContext: import('../../../../node_modules/@types/react/index.d.ts').Context<ToastContextValue | null>;
+export declare const ToastContext: import('react').Context<ToastContextValue | null>;
 /** Access the toast API. Must be called under a `<ToastProvider>`. */
 export declare function useToast(): ToastContextValue;
 //# sourceMappingURL=toast-context.d.ts.map

package/dist/overlay/tour-context.d.ts

@@ -34,7 +34,7 @@ export type TourContextValue = TourState & {
     /** Registered tours, for building a "Take a tour" menu. */
     tours: TourDefinition[];
 };
-export declare const TourContext: import('../../../../node_modules/@types/react/index.d.ts').Context<TourContextValue | null>;
+export declare const TourContext: import('react').Context<TourContextValue | null>;
 /** Access the tour API. Must be called under a `<TourProvider>`. */
 export declare function useTour(): TourContextValue;
 //# sourceMappingURL=tour-context.d.ts.map

package/dist/overlay/tour-types.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { Placement } from '@floating-ui/react';
 /**
  * Public shape of a guided tour. Types only — the runtime lives in tour-model.ts

package/dist/profiles/connections/connectionBrowserModel.d.ts

@@ -2,7 +2,7 @@ import { ComboboxOption } from '../../components/Combobox';
 import { WorkloadKind } from '../../components/workload-picker-utils';
 import { JsonSchemaObject } from '../../components/json-schema-form-types';
 import { QueryBrowserCompletion } from '../../data/query-browser/QueryBrowser.completion';
-import { ReactNode } from '../../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 export type BrowserDescriptor = {
     kind: "query" | "cache";
     provider?: string;

package/dist/profiles/connections/connectionQueryWorkspace.d.ts

@@ -1,6 +1,6 @@
 import { JsonSchemaObject } from '../../components/json-schema-form-types';
 import { QueryBrowserFilterLookup, QueryBrowserRequest, QueryBrowserResult, QueryBrowserResultContext } from '../../data/query-browser/QueryBrowser.types';
-import { ReactNode } from '../../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { BrowserDescriptor, CatalogNode, ProfileRowLimits } from './connectionBrowserModel';
 import { Inspection } from './useInspection';
 import { EsSearch, QueryModeTransition } from '../elasticsearch/esQueryBuilderModel';

package/dist/profiles/editor/profileBuilder.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { ProfileDraft } from './profileBuilderWorkspace';
 export declare function ProfileBuilderAutoOpen({ children }: {
     children: ReactNode;

package/dist/profiles/elasticsearch/esParamOperandExtension.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { EsValue } from './esQueryBuilderModel';
 import { ParamDraft } from '../wizard/profileWizardModel';
 export declare function extendEsParamOperand(input: {