@xelauvas/xela-cli 0.1.0

package/src/commands/resume/resume.tsx

@@ -0,0 +1,275 @@
+import { c as _c } from "react/compiler-runtime";
+import chalk from 'chalk';
+import type { UUID } from 'crypto';
+import figures from 'figures';
+import * as React from 'react';
+import { getOriginalCwd, getSessionId } from '../../bootstrap/state.js';
+import type { CommandResultDisplay, ResumeEntrypoint } from '../../commands.js';
+import { LogSelector } from '../../components/LogSelector.js';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { Spinner } from '../../components/Spinner.js';
+import { useIsInsideModal } from '../../context/modalContext.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import { setClipboard } from '../../ink/termio/osc.js';
+import { Box, Text } from '../../ink.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+import type { LogOption } from '../../types/logs.js';
+import { agenticSessionSearch } from '../../utils/agenticSessionSearch.js';
+import { checkCrossProjectResume } from '../../utils/crossProjectResume.js';
+import { getWorktreePaths } from '../../utils/getWorktreePaths.js';
+import { logError } from '../../utils/log.js';
+import { getLastSessionLog, getSessionIdFromLog, isCustomTitleEnabled, isLiteLog, loadAllProjectsMessageLogs, loadFullLog, loadSameRepoMessageLogs, searchSessionsByCustomTitle } from '../../utils/sessionStorage.js';
+import { validateUuid } from '../../utils/uuid.js';
+type ResumeResult = {
+  resultType: 'sessionNotFound';
+  arg: string;
+} | {
+  resultType: 'multipleMatches';
+  arg: string;
+  count: number;
+};
+function resumeHelpMessage(result: ResumeResult): string {
+  switch (result.resultType) {
+    case 'sessionNotFound':
+      return `Session ${chalk.bold(result.arg)} was not found.`;
+    case 'multipleMatches':
+      return `Found ${result.count} sessions matching ${chalk.bold(result.arg)}. Please use /resume to pick a specific session.`;
+  }
+}
+function ResumeError(t0) {
+  const $ = _c(10);
+  const {
+    message,
+    args,
+    onDone
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== onDone) {
+    t1 = () => {
+      const timer = setTimeout(onDone, 0);
+      return () => clearTimeout(timer);
+    };
+    t2 = [onDone];
+    $[0] = onDone;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  React.useEffect(t1, t2);
+  let t3;
+  if ($[3] !== args) {
+    t3 = <Text dimColor={true}>{figures.pointer} /resume {args}</Text>;
+    $[3] = args;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== message) {
+    t4 = <MessageResponse><Text>{message}</Text></MessageResponse>;
+    $[5] = message;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] !== t3 || $[8] !== t4) {
+    t5 = <Box flexDirection="column">{t3}{t4}</Box>;
+    $[7] = t3;
+    $[8] = t4;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  return t5;
+}
+function ResumeCommand({
+  onDone,
+  onResume
+}: {
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+  onResume: (sessionId: UUID, log: LogOption, entrypoint: ResumeEntrypoint) => Promise<void>;
+}): React.ReactNode {
+  const [logs, setLogs] = React.useState<LogOption[]>([]);
+  const [worktreePaths, setWorktreePaths] = React.useState<string[]>([]);
+  const [loading, setLoading] = React.useState(true);
+  const [resuming, setResuming] = React.useState(false);
+  const [showAllProjects, setShowAllProjects] = React.useState(false);
+  const {
+    rows
+  } = useTerminalSize();
+  const insideModal = useIsInsideModal();
+  const loadLogs = React.useCallback(async (allProjects: boolean, paths: string[]) => {
+    setLoading(true);
+    try {
+      const allLogs = allProjects ? await loadAllProjectsMessageLogs() : await loadSameRepoMessageLogs(paths);
+      const resumable = filterResumableSessions(allLogs, getSessionId());
+      if (resumable.length === 0) {
+        onDone('No conversations found to resume');
+        return;
+      }
+      setLogs(resumable);
+    } catch (_err) {
+      onDone('Failed to load conversations');
+    } finally {
+      setLoading(false);
+    }
+  }, [onDone]);
+  React.useEffect(() => {
+    async function init() {
+      const paths_0 = await getWorktreePaths(getOriginalCwd());
+      setWorktreePaths(paths_0);
+      void loadLogs(false, paths_0);
+    }
+    void init();
+  }, [loadLogs]);
+  const handleToggleAllProjects = React.useCallback(() => {
+    const newValue = !showAllProjects;
+    setShowAllProjects(newValue);
+    void loadLogs(newValue, worktreePaths);
+  }, [showAllProjects, loadLogs, worktreePaths]);
+  async function handleSelect(log: LogOption) {
+    const sessionId = validateUuid(getSessionIdFromLog(log));
+    if (!sessionId) {
+      onDone('Failed to resume conversation');
+      return;
+    }
+
+    // Load full messages for lite logs
+    const fullLog = isLiteLog(log) ? await loadFullLog(log) : log;
+
+    // Check if this conversation is from a different directory
+    const crossProjectCheck = checkCrossProjectResume(fullLog, showAllProjects, worktreePaths);
+    if (crossProjectCheck.isCrossProject) {
+      if (crossProjectCheck.isSameRepoWorktree) {
+        // Same repo worktree - can resume directly
+        setResuming(true);
+        void onResume(sessionId, fullLog, 'slash_command_picker');
+        return;
+      }
+
+      // Different project - show command instead of resuming
+      const raw = await setClipboard(crossProjectCheck.command);
+      if (raw) process.stdout.write(raw);
+
+      // Format the output message
+      const message = ['', 'This conversation is from a different directory.', '', 'To resume, run:', `  ${crossProjectCheck.command}`, '', '(Command copied to clipboard)', ''].join('\n');
+      onDone(message, {
+        display: 'user'
+      });
+      return;
+    }
+
+    // Same directory - proceed with resume
+    setResuming(true);
+    void onResume(sessionId, fullLog, 'slash_command_picker');
+  }
+  function handleCancel() {
+    onDone('Resume cancelled', {
+      display: 'system'
+    });
+  }
+  if (loading) {
+    return <Box>
+        <Spinner />
+        <Text> Loading conversations…</Text>
+      </Box>;
+  }
+  if (resuming) {
+    return <Box>
+        <Spinner />
+        <Text> Resuming conversation…</Text>
+      </Box>;
+  }
+  return <LogSelector logs={logs} maxHeight={insideModal ? Math.floor(rows / 2) : rows - 2} onCancel={handleCancel} onSelect={handleSelect} onLogsChanged={() => loadLogs(showAllProjects, worktreePaths)} showAllProjects={showAllProjects} onToggleAllProjects={handleToggleAllProjects} onAgenticSearch={agenticSessionSearch} />;
+}
+export function filterResumableSessions(logs: LogOption[], currentSessionId: string): LogOption[] {
+  return logs.filter(l => !l.isSidechain && getSessionIdFromLog(l) !== currentSessionId);
+}
+export const call: LocalJSXCommandCall = async (onDone, context, args) => {
+  const onResume = async (sessionId: UUID, log: LogOption, entrypoint: ResumeEntrypoint) => {
+    try {
+      await context.resume?.(sessionId, log, entrypoint);
+      onDone(undefined, {
+        display: 'skip'
+      });
+    } catch (error) {
+      logError(error as Error);
+      onDone(`Failed to resume: ${(error as Error).message}`);
+    }
+  };
+  const arg = args?.trim();
+
+  // No argument provided - show picker
+  if (!arg) {
+    return <ResumeCommand key={Date.now()} onDone={onDone} onResume={onResume} />;
+  }
+
+  // Load logs to search (includes same-repo worktrees)
+  const worktreePaths = await getWorktreePaths(getOriginalCwd());
+  const logs = await loadSameRepoMessageLogs(worktreePaths);
+  if (logs.length === 0) {
+    const message = 'No conversations found to resume.';
+    return <ResumeError message={message} args={arg} onDone={() => onDone(message)} />;
+  }
+
+  // First, check if arg is a valid UUID
+  const maybeSessionId = validateUuid(arg);
+  if (maybeSessionId) {
+    const matchingLogs = logs.filter(l => getSessionIdFromLog(l) === maybeSessionId).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    if (matchingLogs.length > 0) {
+      const log = matchingLogs[0]!;
+      const fullLog = isLiteLog(log) ? await loadFullLog(log) : log;
+      void onResume(maybeSessionId, fullLog, 'slash_command_session_id');
+      return null;
+    }
+
+    // Enriched logs didn't find it — try direct file lookup. This handles
+    // sessions filtered out by enrichLogs (e.g., first message >16KB makes
+    // firstPrompt extraction fail, causing the session to be dropped).
+    const directLog = await getLastSessionLog(maybeSessionId);
+    if (directLog) {
+      void onResume(maybeSessionId, directLog, 'slash_command_session_id');
+      return null;
+    }
+  }
+
+  // Next, try exact custom title match (only if feature is enabled)
+  if (isCustomTitleEnabled()) {
+    const titleMatches = await searchSessionsByCustomTitle(arg, {
+      exact: true
+    });
+    if (titleMatches.length === 1) {
+      const log = titleMatches[0]!;
+      const sessionId = getSessionIdFromLog(log);
+      if (sessionId) {
+        const fullLog = isLiteLog(log) ? await loadFullLog(log) : log;
+        void onResume(sessionId, fullLog, 'slash_command_title');
+        return null;
+      }
+    }
+
+    // Multiple matches - show error
+    if (titleMatches.length > 1) {
+      const message = resumeHelpMessage({
+        resultType: 'multipleMatches',
+        arg,
+        count: titleMatches.length
+      });
+      return <ResumeError message={message} args={arg} onDone={() => onDone(message)} />;
+    }
+  }
+
+  // No match found - show error
+  const message = resumeHelpMessage({
+    resultType: 'sessionNotFound',
+    arg
+  });
+  return <ResumeError message={message} args={arg} onDone={() => onDone(message)} />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","UUID","figures","React","getOriginalCwd","getSessionId","CommandResultDisplay","ResumeEntrypoint","LogSelector","MessageResponse","Spinner","useIsInsideModal","useTerminalSize","setClipboard","Box","Text","LocalJSXCommandCall","LogOption","agenticSessionSearch","checkCrossProjectResume","getWorktreePaths","logError","getLastSessionLog","getSessionIdFromLog","isCustomTitleEnabled","isLiteLog","loadAllProjectsMessageLogs","loadFullLog","loadSameRepoMessageLogs","searchSessionsByCustomTitle","validateUuid","ResumeResult","resultType","arg","count","resumeHelpMessage","result","bold","ResumeError","t0","$","_c","message","args","onDone","t1","t2","timer","setTimeout","clearTimeout","useEffect","t3","pointer","t4","t5","ResumeCommand","onResume","options","display","sessionId","log","entrypoint","Promise","ReactNode","logs","setLogs","useState","worktreePaths","setWorktreePaths","loading","setLoading","resuming","setResuming","showAllProjects","setShowAllProjects","rows","insideModal","loadLogs","useCallback","allProjects","paths","allLogs","resumable","filterResumableSessions","length","_err","init","handleToggleAllProjects","newValue","handleSelect","fullLog","crossProjectCheck","isCrossProject","isSameRepoWorktree","raw","command","process","stdout","write","join","handleCancel","Math","floor","currentSessionId","filter","l","isSidechain","call","context","resume","undefined","error","Error","trim","Date","now","maybeSessionId","matchingLogs","sort","a","b","modified","getTime","directLog","titleMatches","exact"],"sources":["resume.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport type { UUID } from 'crypto'\nimport figures from 'figures'\nimport * as React from 'react'\nimport { getOriginalCwd, getSessionId } from '../../bootstrap/state.js'\nimport type { CommandResultDisplay, ResumeEntrypoint } from '../../commands.js'\nimport { LogSelector } from '../../components/LogSelector.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { Spinner } from '../../components/Spinner.js'\nimport { useIsInsideModal } from '../../context/modalContext.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { setClipboard } from '../../ink/termio/osc.js'\nimport { Box, Text } from '../../ink.js'\nimport type { LocalJSXCommandCall } from '../../types/command.js'\nimport type { LogOption } from '../../types/logs.js'\nimport { agenticSessionSearch } from '../../utils/agenticSessionSearch.js'\nimport { checkCrossProjectResume } from '../../utils/crossProjectResume.js'\nimport { getWorktreePaths } from '../../utils/getWorktreePaths.js'\nimport { logError } from '../../utils/log.js'\nimport {\n  getLastSessionLog,\n  getSessionIdFromLog,\n  isCustomTitleEnabled,\n  isLiteLog,\n  loadAllProjectsMessageLogs,\n  loadFullLog,\n  loadSameRepoMessageLogs,\n  searchSessionsByCustomTitle,\n} from '../../utils/sessionStorage.js'\nimport { validateUuid } from '../../utils/uuid.js'\n\ntype ResumeResult =\n  | { resultType: 'sessionNotFound'; arg: string }\n  | { resultType: 'multipleMatches'; arg: string; count: number }\n\nfunction resumeHelpMessage(result: ResumeResult): string {\n  switch (result.resultType) {\n    case 'sessionNotFound':\n      return `Session ${chalk.bold(result.arg)} was not found.`\n    case 'multipleMatches':\n      return `Found ${result.count} sessions matching ${chalk.bold(result.arg)}. Please use /resume to pick a specific session.`\n  }\n}\n\nfunction ResumeError({\n  message,\n  args,\n  onDone,\n}: {\n  message: string\n  args: string\n  onDone: () => void\n}): React.ReactNode {\n  React.useEffect(() => {\n    const timer = setTimeout(onDone, 0)\n    return () => clearTimeout(timer)\n  }, [onDone])\n\n  return (\n    <Box flexDirection=\"column\">\n      <Text dimColor>\n        {figures.pointer} /resume {args}\n      </Text>\n      <MessageResponse>\n        <Text>{message}</Text>\n      </MessageResponse>\n    </Box>\n  )\n}\n\nfunction ResumeCommand({\n  onDone,\n  onResume,\n}: {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n  onResume: (\n    sessionId: UUID,\n    log: LogOption,\n    entrypoint: ResumeEntrypoint,\n  ) => Promise<void>\n}): React.ReactNode {\n  const [logs, setLogs] = React.useState<LogOption[]>([])\n  const [worktreePaths, setWorktreePaths] = React.useState<string[]>([])\n  const [loading, setLoading] = React.useState(true)\n  const [resuming, setResuming] = React.useState(false)\n  const [showAllProjects, setShowAllProjects] = React.useState(false)\n  const { rows } = useTerminalSize()\n  const insideModal = useIsInsideModal()\n\n  const loadLogs = React.useCallback(\n    async (allProjects: boolean, paths: string[]) => {\n      setLoading(true)\n      try {\n        const allLogs = allProjects\n          ? await loadAllProjectsMessageLogs()\n          : await loadSameRepoMessageLogs(paths)\n        const resumable = filterResumableSessions(allLogs, getSessionId())\n        if (resumable.length === 0) {\n          onDone('No conversations found to resume')\n          return\n        }\n        setLogs(resumable)\n      } catch (_err) {\n        onDone('Failed to load conversations')\n      } finally {\n        setLoading(false)\n      }\n    },\n    [onDone],\n  )\n\n  React.useEffect(() => {\n    async function init() {\n      const paths = await getWorktreePaths(getOriginalCwd())\n      setWorktreePaths(paths)\n      void loadLogs(false, paths)\n    }\n    void init()\n  }, [loadLogs])\n\n  const handleToggleAllProjects = React.useCallback(() => {\n    const newValue = !showAllProjects\n    setShowAllProjects(newValue)\n    void loadLogs(newValue, worktreePaths)\n  }, [showAllProjects, loadLogs, worktreePaths])\n\n  async function handleSelect(log: LogOption) {\n    const sessionId = validateUuid(getSessionIdFromLog(log))\n    if (!sessionId) {\n      onDone('Failed to resume conversation')\n      return\n    }\n\n    // Load full messages for lite logs\n    const fullLog = isLiteLog(log) ? await loadFullLog(log) : log\n\n    // Check if this conversation is from a different directory\n    const crossProjectCheck = checkCrossProjectResume(\n      fullLog,\n      showAllProjects,\n      worktreePaths,\n    )\n    if (crossProjectCheck.isCrossProject) {\n      if (crossProjectCheck.isSameRepoWorktree) {\n        // Same repo worktree - can resume directly\n        setResuming(true)\n        void onResume(sessionId, fullLog, 'slash_command_picker')\n        return\n      }\n\n      // Different project - show command instead of resuming\n      const raw = await setClipboard(crossProjectCheck.command)\n      if (raw) process.stdout.write(raw)\n\n      // Format the output message\n      const message = [\n        '',\n        'This conversation is from a different directory.',\n        '',\n        'To resume, run:',\n        `  ${crossProjectCheck.command}`,\n        '',\n        '(Command copied to clipboard)',\n        '',\n      ].join('\\n')\n\n      onDone(message, { display: 'user' })\n      return\n    }\n\n    // Same directory - proceed with resume\n    setResuming(true)\n    void onResume(sessionId, fullLog, 'slash_command_picker')\n  }\n\n  function handleCancel() {\n    onDone('Resume cancelled', { display: 'system' })\n  }\n\n  if (loading) {\n    return (\n      <Box>\n        <Spinner />\n        <Text> Loading conversations…</Text>\n      </Box>\n    )\n  }\n\n  if (resuming) {\n    return (\n      <Box>\n        <Spinner />\n        <Text> Resuming conversation…</Text>\n      </Box>\n    )\n  }\n\n  return (\n    <LogSelector\n      logs={logs}\n      maxHeight={insideModal ? Math.floor(rows / 2) : rows - 2}\n      onCancel={handleCancel}\n      onSelect={handleSelect}\n      onLogsChanged={() => loadLogs(showAllProjects, worktreePaths)}\n      showAllProjects={showAllProjects}\n      onToggleAllProjects={handleToggleAllProjects}\n      onAgenticSearch={agenticSessionSearch}\n    />\n  )\n}\n\nexport function filterResumableSessions(\n  logs: LogOption[],\n  currentSessionId: string,\n): LogOption[] {\n  return logs.filter(\n    l => !l.isSidechain && getSessionIdFromLog(l) !== currentSessionId,\n  )\n}\n\nexport const call: LocalJSXCommandCall = async (onDone, context, args) => {\n  const onResume = async (\n    sessionId: UUID,\n    log: LogOption,\n    entrypoint: ResumeEntrypoint,\n  ) => {\n    try {\n      await context.resume?.(sessionId, log, entrypoint)\n      onDone(undefined, { display: 'skip' })\n    } catch (error) {\n      logError(error as Error)\n      onDone(`Failed to resume: ${(error as Error).message}`)\n    }\n  }\n\n  const arg = args?.trim()\n\n  // No argument provided - show picker\n  if (!arg) {\n    return (\n      <ResumeCommand key={Date.now()} onDone={onDone} onResume={onResume} />\n    )\n  }\n\n  // Load logs to search (includes same-repo worktrees)\n  const worktreePaths = await getWorktreePaths(getOriginalCwd())\n  const logs = await loadSameRepoMessageLogs(worktreePaths)\n  if (logs.length === 0) {\n    const message = 'No conversations found to resume.'\n    return (\n      <ResumeError\n        message={message}\n        args={arg}\n        onDone={() => onDone(message)}\n      />\n    )\n  }\n\n  // First, check if arg is a valid UUID\n  const maybeSessionId = validateUuid(arg)\n  if (maybeSessionId) {\n    const matchingLogs = logs\n      .filter(l => getSessionIdFromLog(l) === maybeSessionId)\n      .sort((a, b) => b.modified.getTime() - a.modified.getTime())\n\n    if (matchingLogs.length > 0) {\n      const log = matchingLogs[0]!\n      const fullLog = isLiteLog(log) ? await loadFullLog(log) : log\n      void onResume(maybeSessionId, fullLog, 'slash_command_session_id')\n      return null\n    }\n\n    // Enriched logs didn't find it — try direct file lookup. This handles\n    // sessions filtered out by enrichLogs (e.g., first message >16KB makes\n    // firstPrompt extraction fail, causing the session to be dropped).\n    const directLog = await getLastSessionLog(maybeSessionId)\n    if (directLog) {\n      void onResume(maybeSessionId, directLog, 'slash_command_session_id')\n      return null\n    }\n  }\n\n  // Next, try exact custom title match (only if feature is enabled)\n  if (isCustomTitleEnabled()) {\n    const titleMatches = await searchSessionsByCustomTitle(arg, {\n      exact: true,\n    })\n    if (titleMatches.length === 1) {\n      const log = titleMatches[0]!\n      const sessionId = getSessionIdFromLog(log)\n      if (sessionId) {\n        const fullLog = isLiteLog(log) ? await loadFullLog(log) : log\n        void onResume(sessionId, fullLog, 'slash_command_title')\n        return null\n      }\n    }\n\n    // Multiple matches - show error\n    if (titleMatches.length > 1) {\n      const message = resumeHelpMessage({\n        resultType: 'multipleMatches',\n        arg,\n        count: titleMatches.length,\n      })\n      return (\n        <ResumeError\n          message={message}\n          args={arg}\n          onDone={() => onDone(message)}\n        />\n      )\n    }\n  }\n\n  // No match found - show error\n  const message = resumeHelpMessage({ resultType: 'sessionNotFound', arg })\n  return (\n    <ResumeError message={message} args={arg} onDone={() => onDone(message)} />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/commands/review/UltrareviewOverageDialog.tsx

@@ -0,0 +1,96 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useCallback, useRef, useState } from 'react';
+import { Select } from '../../components/CustomSelect/select.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { Box, Text } from '../../ink.js';
+type Props = {
+  onProceed: (signal: AbortSignal) => Promise<void>;
+  onCancel: () => void;
+};
+export function UltrareviewOverageDialog(t0) {
+  const $ = _c(15);
+  const {
+    onProceed,
+    onCancel
+  } = t0;
+  const [isLaunching, setIsLaunching] = useState(false);
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = new AbortController();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const abortControllerRef = useRef(t1);
+  let t2;
+  if ($[1] !== onCancel || $[2] !== onProceed) {
+    t2 = value => {
+      if (value === "proceed") {
+        setIsLaunching(true);
+        onProceed(abortControllerRef.current.signal).catch(() => setIsLaunching(false));
+      } else {
+        onCancel();
+      }
+    };
+    $[1] = onCancel;
+    $[2] = onProceed;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const handleSelect = t2;
+  let t3;
+  if ($[4] !== onCancel) {
+    t3 = () => {
+      abortControllerRef.current.abort();
+      onCancel();
+    };
+    $[4] = onCancel;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const handleCancel = t3;
+  let t4;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = [{
+      label: "Proceed with Extra Usage billing",
+      value: "proceed"
+    }, {
+      label: "Cancel",
+      value: "cancel"
+    }];
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  const options = t4;
+  let t5;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = <Text>Your free ultrareviews for this organization are used. Further reviews bill as Extra Usage (pay-per-use).</Text>;
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  let t6;
+  if ($[8] !== handleCancel || $[9] !== handleSelect || $[10] !== isLaunching) {
+    t6 = <Box flexDirection="column" gap={1}>{t5}{isLaunching ? <Text color="background">Launching…</Text> : <Select options={options} onChange={handleSelect} onCancel={handleCancel} />}</Box>;
+    $[8] = handleCancel;
+    $[9] = handleSelect;
+    $[10] = isLaunching;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  let t7;
+  if ($[12] !== handleCancel || $[13] !== t6) {
+    t7 = <Dialog title="Ultrareview billing" onCancel={handleCancel} color="background">{t6}</Dialog>;
+    $[12] = handleCancel;
+    $[13] = t6;
+    $[14] = t7;
+  } else {
+    t7 = $[14];
+  }
+  return t7;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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