@xortex/xcode 3.0.8 → 3.1.0

package/context/overlayContext.tsx

@@ -0,0 +1,151 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Overlay tracking for Escape key coordination.
+ *
+ * This solves the problem of escape key handling when overlays (like Select with onCancel)
+ * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't
+ * cancel requests when the user just wants to dismiss the overlay.
+ *
+ * Usage:
+ * 1. Call useRegisterOverlay() in any overlay component to automatically register it
+ * 2. Call useIsOverlayActive() to check if any overlay is currently active
+ *
+ * The hook automatically registers on mount and unregisters on unmount,
+ * so no manual cleanup or state management is needed.
+ */
+import { useContext, useEffect, useLayoutEffect } from 'react';
+import instances from '../ink/instances.js';
+import { AppStoreContext, useAppState } from '../state/AppState.js';
+
+// Non-modal overlays that shouldn't disable TextInput focus
+const NON_MODAL_OVERLAYS = new Set(['autocomplete']);
+
+/**
+ * Hook to register a component as an active overlay.
+ * Automatically registers on mount and unregisters on unmount.
+ *
+ * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select')
+ * @param enabled - Whether to register (default: true). Use this to conditionally register
+ *                  based on component props, e.g., only register when onCancel is provided.
+ *
+ * @example
+ * // Conditional registration based on whether cancel is supported
+ * function useSelectInput({ state }) {
+ *   useRegisterOverlay('select', !!state.onCancel)
+ *   // ...
+ * }
+ */
+export function useRegisterOverlay(id, t0) {
+  const $ = _c(8);
+  const enabled = t0 === undefined ? true : t0;
+  const store = useContext(AppStoreContext);
+  const setAppState = store?.setState;
+  let t1;
+  let t2;
+  if ($[0] !== enabled || $[1] !== id || $[2] !== setAppState) {
+    t1 = () => {
+      if (!enabled || !setAppState) {
+        return;
+      }
+      setAppState(prev => {
+        if (prev.activeOverlays.has(id)) {
+          return prev;
+        }
+        const next = new Set(prev.activeOverlays);
+        next.add(id);
+        return {
+          ...prev,
+          activeOverlays: next
+        };
+      });
+      return () => {
+        setAppState(prev_0 => {
+          if (!prev_0.activeOverlays.has(id)) {
+            return prev_0;
+          }
+          const next_0 = new Set(prev_0.activeOverlays);
+          next_0.delete(id);
+          return {
+            ...prev_0,
+            activeOverlays: next_0
+          };
+        });
+      };
+    };
+    t2 = [id, enabled, setAppState];
+    $[0] = enabled;
+    $[1] = id;
+    $[2] = setAppState;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  useEffect(t1, t2);
+  let t3;
+  let t4;
+  if ($[5] !== enabled) {
+    t3 = () => {
+      if (!enabled) {
+        return;
+      }
+      return _temp;
+    };
+    t4 = [enabled];
+    $[5] = enabled;
+    $[6] = t3;
+    $[7] = t4;
+  } else {
+    t3 = $[6];
+    t4 = $[7];
+  }
+  useLayoutEffect(t3, t4);
+}
+
+/**
+ * Hook to check if any overlay is currently active.
+ * This is reactive - the component will re-render when the overlay state changes.
+ *
+ * @returns true if any overlay is currently active
+ *
+ * @example
+ * function CancelRequestHandler() {
+ *   const isOverlayActive = useIsOverlayActive()
+ *   const isActive = !isOverlayActive && canCancelRunningTask
+ *   useKeybinding('chat:cancel', handleCancel, { isActive })
+ * }
+ */
+function _temp() {
+  return instances.get(process.stdout)?.invalidatePrevFrame();
+}
+export function useIsOverlayActive() {
+  return useAppState(_temp2);
+}
+
+/**
+ * Hook to check if any modal overlay is currently active.
+ * Modal overlays are overlays that should capture all input (like Select dialogs).
+ * Non-modal overlays (like autocomplete) don't disable TextInput focus.
+ *
+ * @returns true if any modal overlay is currently active
+ *
+ * @example
+ * // Use for TextInput focus - allows typing during autocomplete
+ * focus: !isSearchingHistory && !isModalOverlayActive
+ */
+function _temp2(s) {
+  return s.activeOverlays.size > 0;
+}
+export function useIsModalOverlayActive() {
+  return useAppState(_temp3);
+}
+function _temp3(s) {
+  for (const id of s.activeOverlays) {
+    if (!NON_MODAL_OVERLAYS.has(id)) {
+      return true;
+    }
+  }
+  return false;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useContext","useEffect","useLayoutEffect","instances","AppStoreContext","useAppState","NON_MODAL_OVERLAYS","Set","useRegisterOverlay","id","t0","$","_c","enabled","undefined","store","setAppState","setState","t1","t2","prev","activeOverlays","has","next","add","prev_0","next_0","delete","t3","t4","_temp","get","process","stdout","invalidatePrevFrame","useIsOverlayActive","_temp2","s","size","useIsModalOverlayActive","_temp3"],"sources":["overlayContext.tsx"],"sourcesContent":["/**\n * Overlay tracking for Escape key coordination.\n *\n * This solves the problem of escape key handling when overlays (like Select with onCancel)\n * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't\n * cancel requests when the user just wants to dismiss the overlay.\n *\n * Usage:\n * 1. Call useRegisterOverlay() in any overlay component to automatically register it\n * 2. Call useIsOverlayActive() to check if any overlay is currently active\n *\n * The hook automatically registers on mount and unregisters on unmount,\n * so no manual cleanup or state management is needed.\n */\nimport { useContext, useEffect, useLayoutEffect } from 'react'\nimport instances from '../ink/instances.js'\nimport { AppStoreContext, useAppState } from '../state/AppState.js'\n\n// Non-modal overlays that shouldn't disable TextInput focus\nconst NON_MODAL_OVERLAYS = new Set(['autocomplete'])\n\n/**\n * Hook to register a component as an active overlay.\n * Automatically registers on mount and unregisters on unmount.\n *\n * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select')\n * @param enabled - Whether to register (default: true). Use this to conditionally register\n *                  based on component props, e.g., only register when onCancel is provided.\n *\n * @example\n * // Conditional registration based on whether cancel is supported\n * function useSelectInput({ state }) {\n *   useRegisterOverlay('select', !!state.onCancel)\n *   // ...\n * }\n */\nexport function useRegisterOverlay(id: string, enabled = true): void {\n  // Use context directly so this is a no-op when rendered outside AppStateProvider\n  // (e.g., in isolated component tests that don't need the full app state tree).\n  const store = useContext(AppStoreContext)\n  const setAppState = store?.setState\n  useEffect(() => {\n    if (!enabled || !setAppState) return\n    setAppState(prev => {\n      if (prev.activeOverlays.has(id)) return prev\n      const next = new Set(prev.activeOverlays)\n      next.add(id)\n      return { ...prev, activeOverlays: next }\n    })\n    return () => {\n      setAppState(prev => {\n        if (!prev.activeOverlays.has(id)) return prev\n        const next = new Set(prev.activeOverlays)\n        next.delete(id)\n        return { ...prev, activeOverlays: next }\n      })\n    }\n  }, [id, enabled, setAppState])\n\n  // On overlay close, force the next render to full-damage diff instead\n  // of blit. A tall overlay (e.g. FuzzyPicker with a 20-line preview)\n  // shrinks the Ink-managed region on unmount; the blit fast path can\n  // copy stale cells from the overlay's previous frame into rows the\n  // shorter layout no longer reaches, leaving a ghost title/divider.\n  // useLayoutEffect so cleanup runs synchronously before the microtask-\n  // deferred onRender (scheduleRender queues a microtask from\n  // resetAfterCommit; passive-effect cleanup would land after it).\n  useLayoutEffect(() => {\n    if (!enabled) return\n    return () => instances.get(process.stdout)?.invalidatePrevFrame()\n  }, [enabled])\n}\n\n/**\n * Hook to check if any overlay is currently active.\n * This is reactive - the component will re-render when the overlay state changes.\n *\n * @returns true if any overlay is currently active\n *\n * @example\n * function CancelRequestHandler() {\n *   const isOverlayActive = useIsOverlayActive()\n *   const isActive = !isOverlayActive && canCancelRunningTask\n *   useKeybinding('chat:cancel', handleCancel, { isActive })\n * }\n */\nexport function useIsOverlayActive(): boolean {\n  return useAppState(s => s.activeOverlays.size > 0)\n}\n\n/**\n * Hook to check if any modal overlay is currently active.\n * Modal overlays are overlays that should capture all input (like Select dialogs).\n * Non-modal overlays (like autocomplete) don't disable TextInput focus.\n *\n * @returns true if any modal overlay is currently active\n *\n * @example\n * // Use for TextInput focus - allows typing during autocomplete\n * focus: !isSearchingHistory && !isModalOverlayActive\n */\nexport function useIsModalOverlayActive(): boolean {\n  return useAppState(s => {\n    for (const id of s.activeOverlays) {\n      if (!NON_MODAL_OVERLAYS.has(id)) return true\n    }\n    return false\n  })\n}\n"],"mappings":"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","ignoreList":[]}

package/context/promptOverlayContext.tsx

@@ -0,0 +1,125 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Portal for content that floats above the prompt so it escapes
+ * FullscreenLayout's bottom-slot `overflowY:hidden` clip.
+ *
+ * The clip is load-bearing (CC-668: tall pastes squash the ScrollBox
+ * without it), but floating overlays use `position:absolute
+ * bottom="100%"` to float above the prompt — and Ink's clip stack
+ * intersects ALL descendants, so they were clipped to ~1 row.
+ *
+ * Two channels:
+ * - `useSetPromptOverlay` — slash-command suggestion data (structured,
+ *   written by PromptInputFooter)
+ * - `useSetPromptOverlayDialog` — arbitrary dialog node (e.g.
+ *   AutoModeOptInDialog, written by PromptInput)
+ *
+ * FullscreenLayout reads both and renders them outside the clipped slot.
+ *
+ * Split into data/setter context pairs so writers never re-render on
+ * their own writes — the setter contexts are stable.
+ */
+import React, { createContext, type ReactNode, useContext, useEffect, useState } from 'react';
+import type { SuggestionItem } from '../components/PromptInput/PromptInputFooterSuggestions.js';
+export type PromptOverlayData = {
+  suggestions: SuggestionItem[];
+  selectedSuggestion: number;
+  maxColumnWidth?: number;
+};
+type Setter<T> = (d: T | null) => void;
+const DataContext = createContext<PromptOverlayData | null>(null);
+const SetContext = createContext<Setter<PromptOverlayData> | null>(null);
+const DialogContext = createContext<ReactNode>(null);
+const SetDialogContext = createContext<Setter<ReactNode> | null>(null);
+export function PromptOverlayProvider(t0) {
+  const $ = _c(6);
+  const {
+    children
+  } = t0;
+  const [data, setData] = useState(null);
+  const [dialog, setDialog] = useState(null);
+  let t1;
+  if ($[0] !== children || $[1] !== dialog) {
+    t1 = <DialogContext.Provider value={dialog}>{children}</DialogContext.Provider>;
+    $[0] = children;
+    $[1] = dialog;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  let t2;
+  if ($[3] !== data || $[4] !== t1) {
+    t2 = <SetContext.Provider value={setData}><SetDialogContext.Provider value={setDialog}><DataContext.Provider value={data}>{t1}</DataContext.Provider></SetDialogContext.Provider></SetContext.Provider>;
+    $[3] = data;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+}
+export function usePromptOverlay() {
+  return useContext(DataContext);
+}
+export function usePromptOverlayDialog() {
+  return useContext(DialogContext);
+}
+
+/**
+ * Register suggestion data for the floating overlay. Clears on unmount.
+ * No-op outside the provider (non-fullscreen renders inline instead).
+ */
+export function useSetPromptOverlay(data) {
+  const $ = _c(4);
+  const set = useContext(SetContext);
+  let t0;
+  let t1;
+  if ($[0] !== data || $[1] !== set) {
+    t0 = () => {
+      if (!set) {
+        return;
+      }
+      set(data);
+      return () => set(null);
+    };
+    t1 = [set, data];
+    $[0] = data;
+    $[1] = set;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t0 = $[2];
+    t1 = $[3];
+  }
+  useEffect(t0, t1);
+}
+
+/**
+ * Register a dialog node to float above the prompt. Clears on unmount.
+ * No-op outside the provider (non-fullscreen renders inline instead).
+ */
+export function useSetPromptOverlayDialog(node) {
+  const $ = _c(4);
+  const set = useContext(SetDialogContext);
+  let t0;
+  let t1;
+  if ($[0] !== node || $[1] !== set) {
+    t0 = () => {
+      if (!set) {
+        return;
+      }
+      set(node);
+      return () => set(null);
+    };
+    t1 = [set, node];
+    $[0] = node;
+    $[1] = set;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t0 = $[2];
+    t1 = $[3];
+  }
+  useEffect(t0, t1);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","ReactNode","useContext","useEffect","useState","SuggestionItem","PromptOverlayData","suggestions","selectedSuggestion","maxColumnWidth","Setter","d","T","DataContext","SetContext","DialogContext","SetDialogContext","PromptOverlayProvider","t0","$","_c","children","data","setData","dialog","setDialog","t1","t2","usePromptOverlay","usePromptOverlayDialog","useSetPromptOverlay","set","useSetPromptOverlayDialog","node"],"sources":["promptOverlayContext.tsx"],"sourcesContent":["/**\n * Portal for content that floats above the prompt so it escapes\n * FullscreenLayout's bottom-slot `overflowY:hidden` clip.\n *\n * The clip is load-bearing (CC-668: tall pastes squash the ScrollBox\n * without it), but floating overlays use `position:absolute\n * bottom=\"100%\"` to float above the prompt — and Ink's clip stack\n * intersects ALL descendants, so they were clipped to ~1 row.\n *\n * Two channels:\n * - `useSetPromptOverlay` — slash-command suggestion data (structured,\n *   written by PromptInputFooter)\n * - `useSetPromptOverlayDialog` — arbitrary dialog node (e.g.\n *   AutoModeOptInDialog, written by PromptInput)\n *\n * FullscreenLayout reads both and renders them outside the clipped slot.\n *\n * Split into data/setter context pairs so writers never re-render on\n * their own writes — the setter contexts are stable.\n */\nimport React, {\n  createContext,\n  type ReactNode,\n  useContext,\n  useEffect,\n  useState,\n} from 'react'\nimport type { SuggestionItem } from '../components/PromptInput/PromptInputFooterSuggestions.js'\n\nexport type PromptOverlayData = {\n  suggestions: SuggestionItem[]\n  selectedSuggestion: number\n  maxColumnWidth?: number\n}\n\ntype Setter<T> = (d: T | null) => void\n\nconst DataContext = createContext<PromptOverlayData | null>(null)\nconst SetContext = createContext<Setter<PromptOverlayData> | null>(null)\nconst DialogContext = createContext<ReactNode>(null)\nconst SetDialogContext = createContext<Setter<ReactNode> | null>(null)\n\nexport function PromptOverlayProvider({\n  children,\n}: {\n  children: ReactNode\n}): ReactNode {\n  const [data, setData] = useState<PromptOverlayData | null>(null)\n  const [dialog, setDialog] = useState<ReactNode>(null)\n  return (\n    <SetContext.Provider value={setData}>\n      <SetDialogContext.Provider value={setDialog}>\n        <DataContext.Provider value={data}>\n          <DialogContext.Provider value={dialog}>\n            {children}\n          </DialogContext.Provider>\n        </DataContext.Provider>\n      </SetDialogContext.Provider>\n    </SetContext.Provider>\n  )\n}\n\nexport function usePromptOverlay(): PromptOverlayData | null {\n  return useContext(DataContext)\n}\n\nexport function usePromptOverlayDialog(): ReactNode {\n  return useContext(DialogContext)\n}\n\n/**\n * Register suggestion data for the floating overlay. Clears on unmount.\n * No-op outside the provider (non-fullscreen renders inline instead).\n */\nexport function useSetPromptOverlay(data: PromptOverlayData | null): void {\n  const set = useContext(SetContext)\n  useEffect(() => {\n    if (!set) return\n    set(data)\n    return () => set(null)\n  }, [set, data])\n}\n\n/**\n * Register a dialog node to float above the prompt. Clears on unmount.\n * No-op outside the provider (non-fullscreen renders inline instead).\n */\nexport function useSetPromptOverlayDialog(node: ReactNode): void {\n  const set = useContext(SetDialogContext)\n  useEffect(() => {\n    if (!set) return\n    set(node)\n    return () => set(null)\n  }, [set, node])\n}\n"],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAOA,KAAK,IACVC,aAAa,EACb,KAAKC,SAAS,EACdC,UAAU,EACVC,SAAS,EACTC,QAAQ,QACH,OAAO;AACd,cAAcC,cAAc,QAAQ,2DAA2D;AAE/F,OAAO,KAAKC,iBAAiB,GAAG;EAC9BC,WAAW,EAAEF,cAAc,EAAE;EAC7BG,kBAAkB,EAAE,MAAM;EAC1BC,cAAc,CAAC,EAAE,MAAM;AACzB,CAAC;AAED,KAAKC,MAAM,CAAC,CAAC,CAAC,GAAG,CAACC,CAAC,EAAEC,CAAC,GAAG,IAAI,EAAE,GAAG,IAAI;AAEtC,MAAMC,WAAW,GAAGb,aAAa,CAACM,iBAAiB,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC;AACjE,MAAMQ,UAAU,GAAGd,aAAa,CAACU,MAAM,CAACJ,iBAAiB,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC;AACxE,MAAMS,aAAa,GAAGf,aAAa,CAACC,SAAS,CAAC,CAAC,IAAI,CAAC;AACpD,MAAMe,gBAAgB,GAAGhB,aAAa,CAACU,MAAM,CAACT,SAAS,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC;AAEtE,OAAO,SAAAgB,sBAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAA+B;IAAAC;EAAA,IAAAH,EAIrC;EACC,OAAAI,IAAA,EAAAC,OAAA,IAAwBnB,QAAQ,CAA2B,IAAI,CAAC;EAChE,OAAAoB,MAAA,EAAAC,SAAA,IAA4BrB,QAAQ,CAAY,IAAI,CAAC;EAAA,IAAAsB,EAAA;EAAA,IAAAP,CAAA,QAAAE,QAAA,IAAAF,CAAA,QAAAK,MAAA;IAK7CE,EAAA,2BAA+BF,KAAM,CAANA,OAAK,CAAC,CAClCH,SAAO,CACV,yBAAyB;IAAAF,CAAA,MAAAE,QAAA;IAAAF,CAAA,MAAAK,MAAA;IAAAL,CAAA,MAAAO,EAAA;EAAA;IAAAA,EAAA,GAAAP,CAAA;EAAA;EAAA,IAAAQ,EAAA;EAAA,IAAAR,CAAA,QAAAG,IAAA,IAAAH,CAAA,QAAAO,EAAA;IAL/BC,EAAA,wBAA4BJ,KAAO,CAAPA,QAAM,CAAC,CACjC,2BAAkCE,KAAS,CAATA,UAAQ,CAAC,CACzC,sBAA6BH,KAAI,CAAJA,KAAG,CAAC,CAC/B,CAAAI,EAEwB,CAC1B,uBACF,4BACF,sBAAsB;IAAAP,CAAA,MAAAG,IAAA;IAAAH,CAAA,MAAAO,EAAA;IAAAP,CAAA,MAAAQ,EAAA;EAAA;IAAAA,EAAA,GAAAR,CAAA;EAAA;EAAA,OARtBQ,EAQsB;AAAA;AAI1B,OAAO,SAAAC,iBAAA;EAAA,OACE1B,UAAU,CAACW,WAAW,CAAC;AAAA;AAGhC,OAAO,SAAAgB,uBAAA;EAAA,OACE3B,UAAU,CAACa,aAAa,CAAC;AAAA;;AAGlC;AACA;AACA;AACA;AACA,OAAO,SAAAe,oBAAAR,IAAA;EAAA,MAAAH,CAAA,GAAAC,EAAA;EACL,MAAAW,GAAA,GAAY7B,UAAU,CAACY,UAAU,CAAC;EAAA,IAAAI,EAAA;EAAA,IAAAQ,EAAA;EAAA,IAAAP,CAAA,QAAAG,IAAA,IAAAH,CAAA,QAAAY,GAAA;IACxBb,EAAA,GAAAA,CAAA;MACR,IAAI,CAACa,GAAG;QAAA;MAAA;MACRA,GAAG,CAACT,IAAI,CAAC;MAAA,OACF,MAAMS,GAAG,CAAC,IAAI,CAAC;IAAA,CACvB;IAAEL,EAAA,IAACK,GAAG,EAAET,IAAI,CAAC;IAAAH,CAAA,MAAAG,IAAA;IAAAH,CAAA,MAAAY,GAAA;IAAAZ,CAAA,MAAAD,EAAA;IAAAC,CAAA,MAAAO,EAAA;EAAA;IAAAR,EAAA,GAAAC,CAAA;IAAAO,EAAA,GAAAP,CAAA;EAAA;EAJdhB,SAAS,CAACe,EAIT,EAAEQ,EAAW,CAAC;AAAA;;AAGjB;AACA;AACA;AACA;AACA,OAAO,SAAAM,0BAAAC,IAAA;EAAA,MAAAd,CAAA,GAAAC,EAAA;EACL,MAAAW,GAAA,GAAY7B,UAAU,CAACc,gBAAgB,CAAC;EAAA,IAAAE,EAAA;EAAA,IAAAQ,EAAA;EAAA,IAAAP,CAAA,QAAAc,IAAA,IAAAd,CAAA,QAAAY,GAAA;IAC9Bb,EAAA,GAAAA,CAAA;MACR,IAAI,CAACa,GAAG;QAAA;MAAA;MACRA,GAAG,CAACE,IAAI,CAAC;MAAA,OACF,MAAMF,GAAG,CAAC,IAAI,CAAC;IAAA,CACvB;IAAEL,EAAA,IAACK,GAAG,EAAEE,IAAI,CAAC;IAAAd,CAAA,MAAAc,IAAA;IAAAd,CAAA,MAAAY,GAAA;IAAAZ,CAAA,MAAAD,EAAA;IAAAC,CAAA,MAAAO,EAAA;EAAA;IAAAR,EAAA,GAAAC,CAAA;IAAAO,EAAA,GAAAP,CAAA;EAAA;EAJdhB,SAAS,CAACe,EAIT,EAAEQ,EAAW,CAAC;AAAA","ignoreList":[]}

package/context/stats.tsx

@@ -0,0 +1,220 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useCallback, useContext, useEffect, useMemo } from 'react';
+import { saveCurrentProjectConfig } from '../utils/config.js';
+export type StatsStore = {
+  increment(name: string, value?: number): void;
+  set(name: string, value: number): void;
+  observe(name: string, value: number): void;
+  add(name: string, value: string): void;
+  getAll(): Record<string, number>;
+};
+function percentile(sorted: number[], p: number): number {
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) {
+    return sorted[lower]!;
+  }
+  return sorted[lower]! + (sorted[upper]! - sorted[lower]!) * (index - lower);
+}
+const RESERVOIR_SIZE = 1024;
+type Histogram = {
+  reservoir: number[];
+  count: number;
+  sum: number;
+  min: number;
+  max: number;
+};
+export function createStatsStore(): StatsStore {
+  const metrics = new Map<string, number>();
+  const histograms = new Map<string, Histogram>();
+  const sets = new Map<string, Set<string>>();
+  return {
+    increment(name: string, value = 1) {
+      metrics.set(name, (metrics.get(name) ?? 0) + value);
+    },
+    set(name: string, value: number) {
+      metrics.set(name, value);
+    },
+    observe(name: string, value: number) {
+      let h = histograms.get(name);
+      if (!h) {
+        h = {
+          reservoir: [],
+          count: 0,
+          sum: 0,
+          min: value,
+          max: value
+        };
+        histograms.set(name, h);
+      }
+      h.count++;
+      h.sum += value;
+      if (value < h.min) {
+        h.min = value;
+      }
+      if (value > h.max) {
+        h.max = value;
+      }
+      // Reservoir sampling (Algorithm R)
+      if (h.reservoir.length < RESERVOIR_SIZE) {
+        h.reservoir.push(value);
+      } else {
+        const j = Math.floor(Math.random() * h.count);
+        if (j < RESERVOIR_SIZE) {
+          h.reservoir[j] = value;
+        }
+      }
+    },
+    add(name: string, value: string) {
+      let s = sets.get(name);
+      if (!s) {
+        s = new Set();
+        sets.set(name, s);
+      }
+      s.add(value);
+    },
+    getAll() {
+      const result: Record<string, number> = Object.fromEntries(metrics);
+      for (const [name, h] of histograms) {
+        if (h.count === 0) {
+          continue;
+        }
+        result[`${name}_count`] = h.count;
+        result[`${name}_min`] = h.min;
+        result[`${name}_max`] = h.max;
+        result[`${name}_avg`] = h.sum / h.count;
+        const sorted = [...h.reservoir].sort((a, b) => a - b);
+        result[`${name}_p50`] = percentile(sorted, 50);
+        result[`${name}_p95`] = percentile(sorted, 95);
+        result[`${name}_p99`] = percentile(sorted, 99);
+      }
+      for (const [name, s] of sets) {
+        result[name] = s.size;
+      }
+      return result;
+    }
+  };
+}
+export const StatsContext = createContext<StatsStore | null>(null);
+type Props = {
+  store?: StatsStore;
+  children: React.ReactNode;
+};
+export function StatsProvider(t0) {
+  const $ = _c(7);
+  const {
+    store: externalStore,
+    children
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = createStatsStore();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const internalStore = t1;
+  const store = externalStore ?? internalStore;
+  let t2;
+  let t3;
+  if ($[1] !== store) {
+    t2 = () => {
+      const flush = () => {
+        const metrics = store.getAll();
+        if (Object.keys(metrics).length > 0) {
+          saveCurrentProjectConfig(current => ({
+            ...current,
+            lastSessionMetrics: metrics
+          }));
+        }
+      };
+      process.on("exit", flush);
+      return () => {
+        process.off("exit", flush);
+      };
+    };
+    t3 = [store];
+    $[1] = store;
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t2 = $[2];
+    t3 = $[3];
+  }
+  useEffect(t2, t3);
+  let t4;
+  if ($[4] !== children || $[5] !== store) {
+    t4 = <StatsContext.Provider value={store}>{children}</StatsContext.Provider>;
+    $[4] = children;
+    $[5] = store;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  return t4;
+}
+export function useStats() {
+  const store = useContext(StatsContext);
+  if (!store) {
+    throw new Error("useStats must be used within a StatsProvider");
+  }
+  return store;
+}
+export function useCounter(name) {
+  const $ = _c(3);
+  const store = useStats();
+  let t0;
+  if ($[0] !== name || $[1] !== store) {
+    t0 = value => store.increment(name, value);
+    $[0] = name;
+    $[1] = store;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+export function useGauge(name) {
+  const $ = _c(3);
+  const store = useStats();
+  let t0;
+  if ($[0] !== name || $[1] !== store) {
+    t0 = value => store.set(name, value);
+    $[0] = name;
+    $[1] = store;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+export function useTimer(name) {
+  const $ = _c(3);
+  const store = useStats();
+  let t0;
+  if ($[0] !== name || $[1] !== store) {
+    t0 = value => store.observe(name, value);
+    $[0] = name;
+    $[1] = store;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+export function useSet(name) {
+  const $ = _c(3);
+  const store = useStats();
+  let t0;
+  if ($[0] !== name || $[1] !== store) {
+    t0 = value => store.add(name, value);
+    $[0] = name;
+    $[1] = store;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","useCallback","useContext","useEffect","useMemo","saveCurrentProjectConfig","StatsStore","increment","name","value","set","observe","add","getAll","Record","percentile","sorted","p","index","length","lower","Math","floor","upper","ceil","RESERVOIR_SIZE","Histogram","reservoir","count","sum","min","max","createStatsStore","metrics","Map","histograms","sets","Set","get","h","push","j","random","s","result","Object","fromEntries","sort","a","b","size","StatsContext","Props","store","children","ReactNode","StatsProvider","t0","$","_c","externalStore","t1","Symbol","for","internalStore","t2","t3","flush","keys","current","lastSessionMetrics","process","on","off","t4","useStats","Error","useCounter","useGauge","useTimer","useSet"],"sources":["stats.tsx"],"sourcesContent":["import React, {\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n} from 'react'\nimport { saveCurrentProjectConfig } from '../utils/config.js'\n\nexport type StatsStore = {\n  increment(name: string, value?: number): void\n  set(name: string, value: number): void\n  observe(name: string, value: number): void\n  add(name: string, value: string): void\n  getAll(): Record<string, number>\n}\n\nfunction percentile(sorted: number[], p: number): number {\n  const index = (p / 100) * (sorted.length - 1)\n  const lower = Math.floor(index)\n  const upper = Math.ceil(index)\n  if (lower === upper) {\n    return sorted[lower]!\n  }\n  return sorted[lower]! + (sorted[upper]! - sorted[lower]!) * (index - lower)\n}\n\nconst RESERVOIR_SIZE = 1024\n\ntype Histogram = {\n  reservoir: number[]\n  count: number\n  sum: number\n  min: number\n  max: number\n}\n\nexport function createStatsStore(): StatsStore {\n  const metrics = new Map<string, number>()\n  const histograms = new Map<string, Histogram>()\n  const sets = new Map<string, Set<string>>()\n\n  return {\n    increment(name: string, value = 1) {\n      metrics.set(name, (metrics.get(name) ?? 0) + value)\n    },\n    set(name: string, value: number) {\n      metrics.set(name, value)\n    },\n    observe(name: string, value: number) {\n      let h = histograms.get(name)\n      if (!h) {\n        h = { reservoir: [], count: 0, sum: 0, min: value, max: value }\n        histograms.set(name, h)\n      }\n      h.count++\n      h.sum += value\n      if (value < h.min) {\n        h.min = value\n      }\n      if (value > h.max) {\n        h.max = value\n      }\n      // Reservoir sampling (Algorithm R)\n      if (h.reservoir.length < RESERVOIR_SIZE) {\n        h.reservoir.push(value)\n      } else {\n        const j = Math.floor(Math.random() * h.count)\n        if (j < RESERVOIR_SIZE) {\n          h.reservoir[j] = value\n        }\n      }\n    },\n    add(name: string, value: string) {\n      let s = sets.get(name)\n      if (!s) {\n        s = new Set()\n        sets.set(name, s)\n      }\n      s.add(value)\n    },\n    getAll() {\n      const result: Record<string, number> = Object.fromEntries(metrics)\n\n      for (const [name, h] of histograms) {\n        if (h.count === 0) {\n          continue\n        }\n        result[`${name}_count`] = h.count\n        result[`${name}_min`] = h.min\n        result[`${name}_max`] = h.max\n        result[`${name}_avg`] = h.sum / h.count\n        const sorted = [...h.reservoir].sort((a, b) => a - b)\n        result[`${name}_p50`] = percentile(sorted, 50)\n        result[`${name}_p95`] = percentile(sorted, 95)\n        result[`${name}_p99`] = percentile(sorted, 99)\n      }\n\n      for (const [name, s] of sets) {\n        result[name] = s.size\n      }\n\n      return result\n    },\n  }\n}\n\nexport const StatsContext = createContext<StatsStore | null>(null)\n\ntype Props = {\n  store?: StatsStore\n  children: React.ReactNode\n}\n\nexport function StatsProvider({\n  store: externalStore,\n  children,\n}: Props): React.ReactNode {\n  const internalStore = useMemo(() => createStatsStore(), [])\n  const store = externalStore ?? internalStore\n\n  useEffect(() => {\n    const flush = () => {\n      const metrics = store.getAll()\n      if (Object.keys(metrics).length > 0) {\n        saveCurrentProjectConfig(current => ({\n          ...current,\n          lastSessionMetrics: metrics,\n        }))\n      }\n    }\n    process.on('exit', flush)\n    return () => {\n      process.off('exit', flush)\n    }\n  }, [store])\n\n  return <StatsContext.Provider value={store}>{children}</StatsContext.Provider>\n}\n\nexport function useStats(): StatsStore {\n  const store = useContext(StatsContext)\n  if (!store) {\n    throw new Error('useStats must be used within a StatsProvider')\n  }\n  return store\n}\n\nexport function useCounter(name: string): (value?: number) => void {\n  const store = useStats()\n  return useCallback(\n    (value?: number) => store.increment(name, value),\n    [store, name],\n  )\n}\n\nexport function useGauge(name: string): (value: number) => void {\n  const store = useStats()\n  return useCallback((value: number) => store.set(name, value), [store, name])\n}\n\nexport function useTimer(name: string): (value: number) => void {\n  const store = useStats()\n  return useCallback(\n    (value: number) => store.observe(name, value),\n    [store, name],\n  )\n}\n\nexport function useSet(name: string): (value: string) => void {\n  const store = useStats()\n  return useCallback((value: string) => store.add(name, value), [store, name])\n}\n"],"mappings":"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","ignoreList":[]}

package/context/voice.tsx

@@ -0,0 +1,88 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useContext, useState, useSyncExternalStore } from 'react';
+import { createStore, type Store } from '../state/store.js';
+export type VoiceState = {
+  voiceState: 'idle' | 'recording' | 'processing';
+  voiceError: string | null;
+  voiceInterimTranscript: string;
+  voiceAudioLevels: number[];
+  voiceWarmingUp: boolean;
+};
+const DEFAULT_STATE: VoiceState = {
+  voiceState: 'idle',
+  voiceError: null,
+  voiceInterimTranscript: '',
+  voiceAudioLevels: [],
+  voiceWarmingUp: false
+};
+type VoiceStore = Store<VoiceState>;
+const VoiceContext = createContext<VoiceStore | null>(null);
+type Props = {
+  children: React.ReactNode;
+};
+export function VoiceProvider(t0) {
+  const $ = _c(3);
+  const {
+    children
+  } = t0;
+  const [store] = useState(_temp);
+  let t1;
+  if ($[0] !== children || $[1] !== store) {
+    t1 = <VoiceContext.Provider value={store}>{children}</VoiceContext.Provider>;
+    $[0] = children;
+    $[1] = store;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+function _temp() {
+  return createStore(DEFAULT_STATE);
+}
+function useVoiceStore() {
+  const store = useContext(VoiceContext);
+  if (!store) {
+    throw new Error("useVoiceState must be used within a VoiceProvider");
+  }
+  return store;
+}
+
+/**
+ * Subscribe to a slice of voice state. Only re-renders when the selected
+ * value changes (compared via Object.is).
+ */
+export function useVoiceState(selector) {
+  const $ = _c(3);
+  const store = useVoiceStore();
+  let t0;
+  if ($[0] !== selector || $[1] !== store) {
+    t0 = () => selector(store.getState());
+    $[0] = selector;
+    $[1] = store;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const get = t0;
+  return useSyncExternalStore(store.subscribe, get, get);
+}
+
+/**
+ * Get the voice state setter. Stable reference — never causes re-renders.
+ * store.setState is synchronous: callers can read getVoiceState() immediately
+ * after to observe the new value (VoiceKeybindingHandler relies on this).
+ */
+export function useSetVoiceState() {
+  return useVoiceStore().setState;
+}
+
+/**
+ * Get a synchronous reader for fresh state inside callbacks. Unlike
+ * useVoiceState (which subscribes), this doesn't cause re-renders — use
+ * inside event handlers that need to read state set earlier in the same tick.
+ */
+export function useGetVoiceState() {
+  return useVoiceStore().getState;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsImNyZWF0ZUNvbnRleHQiLCJ1c2VDb250ZXh0IiwidXNlU3RhdGUiLCJ1c2VTeW5jRXh0ZXJuYWxTdG9yZSIsImNyZWF0ZVN0b3JlIiwiU3RvcmUiLCJWb2ljZVN0YXRlIiwidm9pY2VTdGF0ZSIsInZvaWNlRXJyb3IiLCJ2b2ljZUludGVyaW1UcmFuc2NyaXB0Iiwidm9pY2VBdWRpb0xldmVscyIsInZvaWNlV2FybWluZ1VwIiwiREVGQVVMVF9TVEFURSIsIlZvaWNlU3RvcmUiLCJWb2ljZUNvbnRleHQiLCJQcm9wcyIsImNoaWxkcmVuIiwiUmVhY3ROb2RlIiwiVm9pY2VQcm92aWRlciIsInQwIiwiJCIsIl9jIiwic3RvcmUiLCJfdGVtcCIsInQxIiwidXNlVm9pY2VTdG9yZSIsIkVycm9yIiwidXNlVm9pY2VTdGF0ZSIsInNlbGVjdG9yIiwiZ2V0U3RhdGUiLCJnZXQiLCJzdWJzY3JpYmUiLCJ1c2VTZXRWb2ljZVN0YXRlIiwic2V0U3RhdGUiLCJ1c2VHZXRWb2ljZVN0YXRlIl0sInNvdXJjZXMiOlsidm9pY2UudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCwge1xuICBjcmVhdGVDb250ZXh0LFxuICB1c2VDb250ZXh0LFxuICB1c2VTdGF0ZSxcbiAgdXNlU3luY0V4dGVybmFsU3RvcmUsXG59IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgY3JlYXRlU3RvcmUsIHR5cGUgU3RvcmUgfSBmcm9tICcuLi9zdGF0ZS9zdG9yZS5qcydcblxuZXhwb3J0IHR5cGUgVm9pY2VTdGF0ZSA9IHtcbiAgdm9pY2VTdGF0ZTogJ2lkbGUnIHwgJ3JlY29yZGluZycgfCAncHJvY2Vzc2luZydcbiAgdm9pY2VFcnJvcjogc3RyaW5nIHwgbnVsbFxuICB2b2ljZUludGVyaW1UcmFuc2NyaXB0OiBzdHJpbmdcbiAgdm9pY2VBdWRpb0xldmVsczogbnVtYmVyW11cbiAgdm9pY2VXYXJtaW5nVXA6IGJvb2xlYW5cbn1cblxuY29uc3QgREVGQVVMVF9TVEFURTogVm9pY2VTdGF0ZSA9IHtcbiAgdm9pY2VTdGF0ZTogJ2lkbGUnLFxuICB2b2ljZUVycm9yOiBudWxsLFxuICB2b2ljZUludGVyaW1UcmFuc2NyaXB0OiAnJyxcbiAgdm9pY2VBdWRpb0xldmVsczogW10sXG4gIHZvaWNlV2FybWluZ1VwOiBmYWxzZSxcbn1cblxudHlwZSBWb2ljZVN0b3JlID0gU3RvcmU8Vm9pY2VTdGF0ZT5cblxuY29uc3QgVm9pY2VDb250ZXh0ID0gY3JlYXRlQ29udGV4dDxWb2ljZVN0b3JlIHwgbnVsbD4obnVsbClcblxudHlwZSBQcm9wcyA9IHtcbiAgY2hpbGRyZW46IFJlYWN0LlJlYWN0Tm9kZVxufVxuXG5leHBvcnQgZnVuY3Rpb24gVm9pY2VQcm92aWRlcih7IGNoaWxkcmVuIH06IFByb3BzKTogUmVhY3QuUmVhY3ROb2RlIHtcbiAgLy8gU3RvcmUgaXMgY3JlYXRlZCBvbmNlIOKAlCBzdGFibGUgY29udGV4dCB2YWx1ZSBtZWFucyB0aGUgcHJvdmlkZXIgbmV2ZXJcbiAgLy8gdHJpZ2dlcnMgcmUtcmVuZGVycy4gQ29uc3VtZXJzIHN1YnNjcmliZSB0byBzbGljZXMgdmlhIHVzZVZvaWNlU3RhdGUuXG4gIGNvbnN0IFtzdG9yZV0gPSB1c2VTdGF0ZSgoKSA9PiBjcmVhdGVTdG9yZTxWb2ljZVN0YXRlPihERUZBVUxUX1NUQVRFKSlcbiAgcmV0dXJuIDxWb2ljZUNvbnRleHQuUHJvdmlkZXIgdmFsdWU9e3N0b3JlfT57Y2hpbGRyZW59PC9Wb2ljZUNvbnRleHQuUHJvdmlkZXI+XG59XG5cbmZ1bmN0aW9uIHVzZVZvaWNlU3RvcmUoKTogVm9pY2VTdG9yZSB7XG4gIGNvbnN0IHN0b3JlID0gdXNlQ29udGV4dChWb2ljZUNvbnRleHQpXG4gIGlmICghc3RvcmUpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ3VzZVZvaWNlU3RhdGUgbXVzdCBiZSB1c2VkIHdpdGhpbiBhIFZvaWNlUHJvdmlkZXInKVxuICB9XG4gIHJldHVybiBzdG9yZVxufVxuXG4vKipcbiAqIFN1YnNjcmliZSB0byBhIHNsaWNlIG9mIHZvaWNlIHN0YXRlLiBPbmx5IHJlLXJlbmRlcnMgd2hlbiB0aGUgc2VsZWN0ZWRcbiAqIHZhbHVlIGNoYW5nZXMgKGNvbXBhcmVkIHZpYSBPYmplY3QuaXMpLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdXNlVm9pY2VTdGF0ZTxUPihzZWxlY3RvcjogKHN0YXRlOiBWb2ljZVN0YXRlKSA9PiBUKTogVCB7XG4gIGNvbnN0IHN0b3JlID0gdXNlVm9pY2VTdG9yZSgpXG4gIGNvbnN0IGdldCA9ICgpID0+IHNlbGVjdG9yKHN0b3JlLmdldFN0YXRlKCkpXG4gIHJldHVybiB1c2VTeW5jRXh0ZXJuYWxTdG9yZShzdG9yZS5zdWJzY3JpYmUsIGdldCwgZ2V0KVxufVxuXG4vKipcbiAqIEdldCB0aGUgdm9pY2Ugc3RhdGUgc2V0dGVyLiBTdGFibGUgcmVmZXJlbmNlIOKAlCBuZXZlciBjYXVzZXMgcmUtcmVuZGVycy5cbiAqIHN0b3JlLnNldFN0YXRlIGlzIHN5bmNocm9ub3VzOiBjYWxsZXJzIGNhbiByZWFkIGdldFZvaWNlU3RhdGUoKSBpbW1lZGlhdGVseVxuICogYWZ0ZXIgdG8gb2JzZXJ2ZSB0aGUgbmV3IHZhbHVlIChWb2ljZUtleWJpbmRpbmdIYW5kbGVyIHJlbGllcyBvbiB0aGlzKS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHVzZVNldFZvaWNlU3RhdGUoKTogKFxuICB1cGRhdGVyOiAocHJldjogVm9pY2VTdGF0ZSkgPT4gVm9pY2VTdGF0ZSxcbikgPT4gdm9pZCB7XG4gIHJldHVybiB1c2VWb2ljZVN0b3JlKCkuc2V0U3RhdGVcbn1cblxuLyoqXG4gKiBHZXQgYSBzeW5jaHJvbm91cyByZWFkZXIgZm9yIGZyZXNoIHN0YXRlIGluc2lkZSBjYWxsYmFja3MuIFVubGlrZVxuICogdXNlVm9pY2VTdGF0ZSAod2hpY2ggc3Vic2NyaWJlcyksIHRoaXMgZG9lc24ndCBjYXVzZSByZS1yZW5kZXJzIOKAlCB1c2VcbiAqIGluc2lkZSBldmVudCBoYW5kbGVycyB0aGF0IG5lZWQgdG8gcmVhZCBzdGF0ZSBzZXQgZWFybGllciBpbiB0aGUgc2FtZSB0aWNrLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdXNlR2V0Vm9pY2VTdGF0ZSgpOiAoKSA9PiBWb2ljZVN0YXRlIHtcbiAgcmV0dXJuIHVzZVZvaWNlU3RvcmUoKS5nZXRTdGF0ZVxufVxuIl0sIm1hcHBpbmdzIjoiO0FBQUEsT0FBT0EsS0FBSyxJQUNWQyxhQUFhLEVBQ2JDLFVBQVUsRUFDVkMsUUFBUSxFQUNSQyxvQkFBb0IsUUFDZixPQUFPO0FBQ2QsU0FBU0MsV0FBVyxFQUFFLEtBQUtDLEtBQUssUUFBUSxtQkFBbUI7QUFFM0QsT0FBTyxLQUFLQyxVQUFVLEdBQUc7RUFDdkJDLFVBQVUsRUFBRSxNQUFNLEdBQUcsV0FBVyxHQUFHLFlBQVk7RUFDL0NDLFVBQVUsRUFBRSxNQUFNLEdBQUcsSUFBSTtFQUN6QkMsc0JBQXNCLEVBQUUsTUFBTTtFQUM5QkMsZ0JBQWdCLEVBQUUsTUFBTSxFQUFFO0VBQzFCQyxjQUFjLEVBQUUsT0FBTztBQUN6QixDQUFDO0FBRUQsTUFBTUMsYUFBYSxFQUFFTixVQUFVLEdBQUc7RUFDaENDLFVBQVUsRUFBRSxNQUFNO0VBQ2xCQyxVQUFVLEVBQUUsSUFBSTtFQUNoQkMsc0JBQXNCLEVBQUUsRUFBRTtFQUMxQkMsZ0JBQWdCLEVBQUUsRUFBRTtFQUNwQkMsY0FBYyxFQUFFO0FBQ2xCLENBQUM7QUFFRCxLQUFLRSxVQUFVLEdBQUdSLEtBQUssQ0FBQ0MsVUFBVSxDQUFDO0FBRW5DLE1BQU1RLFlBQVksR0FBR2QsYUFBYSxDQUFDYSxVQUFVLEdBQUcsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDO0FBRTNELEtBQUtFLEtBQUssR0FBRztFQUNYQyxRQUFRLEVBQUVqQixLQUFLLENBQUNrQixTQUFTO0FBQzNCLENBQUM7QUFFRCxPQUFPLFNBQUFDLGNBQUFDLEVBQUE7RUFBQSxNQUFBQyxDQUFBLEdBQUFDLEVBQUE7RUFBdUI7SUFBQUw7RUFBQSxJQUFBRyxFQUFtQjtFQUcvQyxPQUFBRyxLQUFBLElBQWdCcEIsUUFBUSxDQUFDcUIsS0FBNEMsQ0FBQztFQUFBLElBQUFDLEVBQUE7RUFBQSxJQUFBSixDQUFBLFFBQUFKLFFBQUEsSUFBQUksQ0FBQSxRQUFBRSxLQUFBO0lBQy9ERSxFQUFBLDBCQUE4QkYsS0FBSyxDQUFMQSxNQUFJLENBQUMsQ0FBR04sU0FBTyxDQUFFLHdCQUF3QjtJQUFBSSxDQUFBLE1BQUFKLFFBQUE7SUFBQUksQ0FBQSxNQUFBRSxLQUFBO0lBQUFGLENBQUEsTUFBQUksRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQUosQ0FBQTtFQUFBO0VBQUEsT0FBdkVJLEVBQXVFO0FBQUE7QUFKekUsU0FBQUQsTUFBQTtFQUFBLE9BRzBCbkIsV0FBVyxDQUFhUSxhQUFhLENBQUM7QUFBQTtBQUl2RSxTQUFBYSxjQUFBO0VBQ0UsTUFBQUgsS0FBQSxHQUFjckIsVUFBVSxDQUFDYSxZQUFZLENBQUM7RUFDdEMsSUFBSSxDQUFDUSxLQUFLO0lBQ1IsTUFBTSxJQUFJSSxLQUFLLENBQUMsbURBQW1ELENBQUM7RUFBQTtFQUNyRSxPQUNNSixLQUFLO0FBQUE7O0FBR2Q7QUFDQTtBQUNBO0FBQ0E7QUFDQSxPQUFPLFNBQUFLLGNBQUFDLFFBQUE7RUFBQSxNQUFBUixDQUFBLEdBQUFDLEVBQUE7RUFDTCxNQUFBQyxLQUFBLEdBQWNHLGFBQWEsQ0FBQyxDQUFDO0VBQUEsSUFBQU4sRUFBQTtFQUFBLElBQUFDLENBQUEsUUFBQVEsUUFBQSxJQUFBUixDQUFBLFFBQUFFLEtBQUE7SUFDakJILEVBQUEsR0FBQUEsQ0FBQSxLQUFNUyxRQUFRLENBQUNOLEtBQUssQ0FBQU8sUUFBUyxDQUFDLENBQUMsQ0FBQztJQUFBVCxDQUFBLE1BQUFRLFFBQUE7SUFBQVIsQ0FBQSxNQUFBRSxLQUFBO0lBQUFGLENBQUEsTUFBQUQsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQUMsQ0FBQTtFQUFBO0VBQTVDLE1BQUFVLEdBQUEsR0FBWVgsRUFBZ0M7RUFBQSxPQUNyQ2hCLG9CQUFvQixDQUFDbUIsS0FBSyxDQUFBUyxTQUFVLEVBQUVELEdBQUcsRUFBRUEsR0FBRyxDQUFDO0FBQUE7O0FBR3hEO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQSxPQUFPLFNBQUFFLGlCQUFBO0VBQUEsT0FHRVAsYUFBYSxDQUFDLENBQUMsQ0FBQVEsUUFBUztBQUFBOztBQUdqQztBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsT0FBTyxTQUFBQyxpQkFBQTtFQUFBLE9BQ0VULGFBQWEsQ0FBQyxDQUFDLENBQUFJLFFBQVM7QUFBQSIsImlnbm9yZUxpc3QiOltdfQ==