@bugbug-io/cli 13.39.1

package/dist/NavigatorApp-WSJMM3OT.js

@@ -0,0 +1,2410 @@
+import {
+  BaseSuiteRunDetails,
+  BaseTestRunDetails,
+  DEFAULT_RESERVED_TERMINAL_ROWS,
+  EscProvider,
+  MenuList,
+  ROUTES,
+  SelectableOption,
+  SelectionPrefix,
+  ShortcutProvider,
+  Status,
+  ViewLayout,
+  VirtualizedList,
+  analytics,
+  defaultJunitReportPath,
+  detectFormat,
+  exportProject,
+  exportTest,
+  formatCwd,
+  formatDuration,
+  formatErrorMessage,
+  formatRunStatus,
+  getCliConfig,
+  getIdentity,
+  getProjectById,
+  getSuite,
+  getSuiteDetails,
+  getSuiteRunDetails,
+  getSuiteRunTestRuns,
+  getTest,
+  getTestDetails,
+  getTestRunDetails,
+  getTestRunJunitReport,
+  getVersion,
+  hasProjectConfigFile,
+  importProject,
+  importTest,
+  initProject,
+  isAuthenticationError,
+  isAuthorizationError,
+  listProfiles,
+  listProjects,
+  listSuiteRuns,
+  listTestRunDebugArtifacts,
+  listTestRuns,
+  loadSuiteTableResources,
+  loadTestTableResources,
+  login,
+  logout,
+  openExternalUrl,
+  runSuite,
+  runTest,
+  switchProject,
+  updateSdkConfig,
+  useEscHandler,
+  useShortcutBlocker,
+  useShortcutHandler,
+  useTheme,
+  userCwd,
+  writeReportXml
+} from "./chunk-NTNHB6R6.js";
+
+// src/app/NavigatorApp.tsx
+import { useState as useState17 } from "react";
+import { RouterProvider } from "react-router";
+
+// src/app/contexts/navigatorSession/NavigatorSessionContext.tsx
+import { createContext, useCallback, useContext, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var applyAuthState = (config, authState) => ({
+  ...config,
+  ...authState.token !== void 0 ? { token: authState.token } : {},
+  ...authState.projectId !== void 0 ? { projectId: authState.projectId } : {}
+});
+var getAuthStatus = (config, authState) => ({
+  kind: config.token && config.projectId ? "ready" : "prompt",
+  token: config.token,
+  projectId: config.projectId,
+  isUserToken: authState.isUserToken === true,
+  apiUrl: config.apiUrl
+});
+var syncInitialSdkConfig = () => {
+  const config = getCliConfig();
+  if (config.token) {
+    updateSdkConfig({
+      apiToken: config.token,
+      ...config.projectId ? { projectId: config.projectId } : {}
+    });
+  }
+  return {};
+};
+var NavigatorSessionContext = createContext(null);
+var NavigatorSessionProvider = ({ children }) => {
+  const [authState, setAuthState] = useState(
+    () => syncInitialSdkConfig()
+  );
+  const [authError, setAuthError] = useState(null);
+  const config = applyAuthState(getCliConfig(), authState);
+  const auth = getAuthStatus(config, authState);
+  const completeSession = useCallback(
+    (token, projectId, options = {}) => {
+      try {
+        const trimmedToken = token.trim();
+        if (!trimmedToken) throw new Error("Token must not be empty.");
+        const trimmedProjectId = projectId.trim();
+        if (!trimmedProjectId) throw new Error("Project id must not be empty.");
+        const nextAuthState = {
+          token: trimmedToken,
+          projectId: trimmedProjectId,
+          isUserToken: options.isUserToken === true
+        };
+        updateSdkConfig({ apiToken: nextAuthState.token, projectId: nextAuthState.projectId });
+        analytics.refreshWithToken(trimmedToken);
+        analytics.trackEvent("cli_session_configured", { success: true });
+        if (config.projectId !== trimmedProjectId) {
+          analytics.trackEvent("cli_session_project_switched", { success: true });
+        }
+        analytics.trackEvent("cli_session_started");
+        setAuthState(nextAuthState);
+        setAuthError(null);
+      } catch (err) {
+        analytics.trackEvent("cli_session_configured", { success: false });
+        setAuthError(err instanceof Error ? err.message : String(err));
+      }
+    },
+    [config.projectId]
+  );
+  const clearSession = useCallback(() => {
+    setAuthState({});
+    setAuthError(null);
+  }, []);
+  const setSessionProject = useCallback((projectId) => {
+    try {
+      const trimmedProjectId = projectId.trim();
+      if (!trimmedProjectId) throw new Error("Project id must not be empty.");
+      updateSdkConfig({ projectId: trimmedProjectId });
+      setAuthState((current) => ({ ...current, projectId: trimmedProjectId }));
+      setAuthError(null);
+      analytics.trackEvent("cli_session_project_switched", { success: true });
+    } catch (err) {
+      analytics.trackEvent("cli_session_project_switched", { success: false });
+      setAuthError(err instanceof Error ? err.message : String(err));
+    }
+  }, []);
+  return /* @__PURE__ */ jsx(
+    NavigatorSessionContext.Provider,
+    {
+      value: { auth, config, authError, completeSession, clearSession, setSessionProject },
+      children
+    }
+  );
+};
+var useNavigatorSession = () => {
+  const ctx = useContext(NavigatorSessionContext);
+  if (!ctx) {
+    throw new Error("useNavigatorSession must be used within a NavigatorSessionProvider.");
+  }
+  return ctx;
+};
+
+// src/app/router.tsx
+import { createMemoryRouter, createRoutesFromElements, Route } from "react-router";
+
+// src/app/Navigator.tsx
+import { Box as Box4, useApp, useInput } from "ink";
+import { useState as useState4 } from "react";
+import { Outlet, useLocation as useLocation3, useNavigate as useNavigate2 } from "react-router";
+
+// src/app/components/AuthGate/AuthGate.tsx
+import { useEffect as useEffect2 } from "react";
+import { useLocation, useNavigate } from "react-router";
+
+// src/app/hooks/useConnectionStatus.ts
+import { useEffect, useState as useState2 } from "react";
+var PING_INTERVAL_MS = 15e3;
+var getConnectionStatus = async () => {
+  try {
+    const identity = await getIdentity();
+    return { state: "ok", message: "API connectivity successful", identity };
+  } catch (err) {
+    if (isAuthenticationError(err) || isAuthorizationError(err)) {
+      return { state: "unauthenticated", message: "API token is invalid or missing" };
+    }
+    return {
+      state: "error",
+      message: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+};
+var useConnectionStatus = (enabled) => {
+  const [status, setStatus] = useState2({ state: "checking" });
+  useEffect(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    let cancelled = false;
+    const ping = async () => {
+      const nextStatus = await getConnectionStatus();
+      if (!cancelled) setStatus(nextStatus);
+    };
+    ping();
+    const interval = setInterval(() => {
+      ping();
+    }, PING_INTERVAL_MS);
+    return () => {
+      cancelled = true;
+      clearInterval(interval);
+    };
+  }, [enabled]);
+  return status;
+};
+
+// src/app/components/AuthGate/AuthGate.tsx
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+var INIT_ROUTE = "/init";
+var AuthGate = ({ children }) => {
+  const { auth } = useNavigatorSession();
+  const location = useLocation();
+  const navigate = useNavigate();
+  const onInitRoute = location.pathname === INIT_ROUTE;
+  const hasConfiguredAuth = auth.kind === "ready";
+  const connectionStatus = useConnectionStatus(hasConfiguredAuth);
+  const authCheckPending = hasConfiguredAuth && connectionStatus.state === "checking";
+  const authRejected = hasConfiguredAuth && connectionStatus.state === "unauthenticated";
+  const authenticated = hasConfiguredAuth && !authRejected;
+  useEffect2(() => {
+    if (!authCheckPending && !authenticated && !onInitRoute) {
+      navigate(INIT_ROUTE, {
+        state: {
+          redirectUrl: location.pathname,
+          onlyThisSession: true,
+          ...authRejected ? { ignoreConfiguredAuth: true } : {}
+        },
+        replace: true
+      });
+    }
+  }, [authCheckPending, authenticated, authRejected, onInitRoute, location.pathname, navigate]);
+  if (authCheckPending) return null;
+  if (authenticated) return /* @__PURE__ */ jsx2(Fragment, { children: children(true) });
+  if (onInitRoute) return /* @__PURE__ */ jsx2(Fragment, { children: children(false) });
+  return null;
+};
+
+// src/app/components/Header/Header.tsx
+import { Box, Text } from "ink";
+
+// src/app/hooks/useFeatureQuery.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useState as useState3 } from "react";
+var useFeatureQuery = (fn, deps) => {
+  const [data, setData] = useState3(void 0);
+  const [isFetching, setIsFetching] = useState3(true);
+  const [error, setError] = useState3(void 0);
+  const [refreshIndex, setRefreshIndex] = useState3(0);
+  useEffect3(() => {
+    let cancelled = false;
+    setIsFetching(true);
+    setError(void 0);
+    const run = async () => {
+      try {
+        const result = await fn();
+        if (!cancelled) setData(result);
+      } catch (err) {
+        if (!cancelled) setError(formatErrorMessage(err));
+      } finally {
+        if (!cancelled) setIsFetching(false);
+      }
+    };
+    run().catch((err) => {
+      if (!cancelled) {
+        setError(formatErrorMessage(err));
+        setIsFetching(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [refreshIndex, ...deps]);
+  const refetch = useCallback2(() => {
+    setRefreshIndex((index) => index + 1);
+  }, []);
+  return {
+    data,
+    isLoading: isFetching && data === void 0,
+    isFetching,
+    isError: error !== void 0,
+    error,
+    refetch
+  };
+};
+
+// src/app/hooks/useCurrentProject.ts
+var useCurrentProject = (enabled) => {
+  const { auth } = useNavigatorSession();
+  const projectId = enabled ? auth.projectId : void 0;
+  const query = useFeatureQuery(
+    () => projectId ? getProjectById(projectId) : Promise.resolve(null),
+    [projectId]
+  );
+  return query.data ?? void 0;
+};
+
+// src/app/components/Header/Header.constants.ts
+var VERSION = getVersion();
+var BUGBUG_LOGO_ASCII = [
+  "\u2584    \u2584    ",
+  "\u2588\u2588\u2588  \u2588\u2588\u2588 ",
+  "\u2580\u2580\u2580  \u2580\u2580\u2580 ",
+  "\u2584\u2584    \u2584\u2584 ",
+  "  \u2580\u2580\u2580\u2580    "
+].join("\n");
+var STATUS_LABEL = {
+  checking: "Connecting...",
+  ok: "Authenticated",
+  unauthenticated: "Unauthenticated",
+  error: "Disconnected"
+};
+var STATUS_COLOR = {
+  checking: "yellow",
+  ok: void 0,
+  unauthenticated: "yellow",
+  error: "red"
+};
+
+// src/app/components/Header/Header.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var Header = ({ authenticated }) => {
+  const { theme } = useTheme();
+  const status = useConnectionStatus(authenticated);
+  const project = useCurrentProject(authenticated);
+  const identity = authenticated ? status.identity : void 0;
+  const state = authenticated ? status.state : "unauthenticated";
+  const showDetail = authenticated && (status.state === "error" || status.state === "unauthenticated") && !!status.message;
+  return /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+    /* @__PURE__ */ jsx3(Box, { marginRight: 1, children: /* @__PURE__ */ jsx3(Text, { color: theme.colors.brand, children: BUGBUG_LOGO_ASCII }) }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx3(Text, { bold: true, children: "BugBug" }),
+        " ",
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "v",
+          VERSION
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx3(Text, { dimColor: true, children: "Your interactive quality buddy" }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx3(Text, { dimColor: true, children: "Status: " }),
+        /* @__PURE__ */ jsx3(Text, { color: STATUS_COLOR[state], dimColor: state === "ok", children: STATUS_LABEL[state] }),
+        authenticated && identity && /* @__PURE__ */ jsx3(Text, { dimColor: true, children: identity.tokenType === "user" ? ` (logged in as ${identity.name})` : ` (via ${identity.tokenType} token)` }),
+        showDetail ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          " (",
+          status.message,
+          ")"
+        ] }) : null
+      ] }),
+      authenticated && project ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "Project: ",
+        project.name ?? "Untitled project",
+        " at ",
+        project.organizationName
+      ] }) : /* @__PURE__ */ jsx3(Text, { dimColor: true, children: " " }),
+      /* @__PURE__ */ jsx3(Text, { dimColor: true, children: formatCwd(userCwd()) })
+    ] })
+  ] });
+};
+
+// src/features/tui/components/Breadcrumb/Breadcrumb.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { useLocation as useLocation2 } from "react-router";
+
+// src/app/routeLabels.ts
+var CRUMB_LABELS = {
+  "/tests": "Tests",
+  "/tests/list": "List",
+  "/tests/import": "Import",
+  "/tests/run": "Run",
+  "/tests/:testId": "Details",
+  "/tests/:testId/run": "Run",
+  "/tests/:testId/lastRun": "Show last run",
+  "/tests/:testId/export": "Export",
+  "/tests/:testId/open": "Open in BugBug",
+  "/testruns": "Test runs",
+  "/testruns/list": "List",
+  "/testruns/:runId": "Details",
+  "/testruns/:runId/debugArtifacts": "Show run artifacts",
+  "/testruns/:runId/junitReport": "Download JUnit report",
+  "/testruns/:runId/open": "Open in BugBug",
+  "/suites": "Suites",
+  "/suites/list": "List",
+  "/suites/run": "Run",
+  "/suites/:suiteId": "Details",
+  "/suites/:suiteId/run": "Run",
+  "/suites/:suiteId/lastRun": "Show last run",
+  "/suites/:suiteId/open": "Open in BugBug",
+  "/suiteruns": "Suite runs",
+  "/suiteruns/list": "List",
+  "/suiteruns/:runId": "Details",
+  "/suiteruns/:runId/showTestRuns": "Show test runs",
+  "/suiteruns/:runId/open": "Open in BugBug",
+  "/profiles": "Profiles",
+  "/profiles/list": "List",
+  "/project": "Project",
+  "/project/export": "Export",
+  "/project/import": "Import",
+  "/settings": "Settings",
+  "/settings/setSessionToken": "Set session token",
+  "/logout": "Logout"
+};
+
+// src/features/tui/tui.utils.ts
+var ROOT_LABEL = "Main menu";
+var normalizePath = (pathname) => {
+  const trimmed = pathname.replace(/\/+$/, "");
+  return trimmed === "" ? "/" : trimmed;
+};
+var pathSegments = (pathname) => normalizePath(pathname).split("/").filter(Boolean);
+var matchesPattern = (pattern, pathname) => {
+  const patternSegments = pathSegments(pattern);
+  const currentSegments = pathSegments(pathname);
+  if (patternSegments.length !== currentSegments.length) return false;
+  return patternSegments.every(
+    (segment, index) => segment.startsWith(":") || segment === currentSegments[index]
+  );
+};
+var findLabel = (pathname, labels) => {
+  const normalizedPath = normalizePath(pathname);
+  const exact = labels[normalizedPath];
+  if (exact) return exact;
+  const wildcard = Object.entries(labels).find(
+    ([pattern]) => matchesPattern(pattern, normalizedPath)
+  );
+  return wildcard?.[1];
+};
+var buildBreadcrumb = (pathname, labels) => {
+  const parts = [ROOT_LABEL];
+  const segments = pathSegments(pathname);
+  for (let index = 0; index < segments.length; index += 1) {
+    const prefix = `/${segments.slice(0, index + 1).join("/")}`;
+    const label = findLabel(prefix, labels);
+    if (label && parts[parts.length - 1] !== label) parts.push(label);
+  }
+  return parts.join(" \u203A ");
+};
+
+// src/features/tui/components/Breadcrumb/Breadcrumb.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var Breadcrumb = () => {
+  const { pathname } = useLocation2();
+  return /* @__PURE__ */ jsx4(Box2, { marginBottom: 1, children: /* @__PURE__ */ jsx4(Text2, { bold: true, color: "cyan", children: buildBreadcrumb(pathname, CRUMB_LABELS) }) });
+};
+
+// src/features/tui/components/ShortcutsGrid/ShortcutsGrid.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var GLOBAL_SHORTCUTS = [
+  { shortcut: "t", label: "Tests" },
+  { shortcut: "r", label: "Test runs" },
+  { shortcut: "s", label: "Suites" },
+  { shortcut: "u", label: "Suite runs" },
+  { shortcut: "f", label: "Profiles" },
+  { shortcut: "p", label: "Project" },
+  { shortcut: ",", label: "Settings" },
+  { shortcut: "Esc", label: "Back" },
+  { shortcut: "q", label: "Close at main menu" },
+  { shortcut: "Ctrl-C", label: "Exit" }
+];
+var ACTION_SHORTCUTS = [
+  { shortcut: "Enter", label: "Select" },
+  { shortcut: "/", label: "Search" },
+  { shortcut: "l", label: "List or logs" },
+  { shortcut: "r", label: "Run" },
+  { shortcut: "i", label: "Import" },
+  { shortcut: "e", label: "Export" },
+  { shortcut: "o", label: "Open in BugBug" },
+  { shortcut: "h", label: "Last run" },
+  { shortcut: "a", label: "Artifacts" },
+  { shortcut: "t", label: "Suite run tests" }
+];
+var ShortcutColumn = ({ title, items }) => /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", marginRight: 4, children: [
+  /* @__PURE__ */ jsx5(Text3, { bold: true, children: title }),
+  items.map(({ shortcut, label }) => /* @__PURE__ */ jsxs2(Text3, { children: [
+    /* @__PURE__ */ jsx5(Text3, { color: "cyan", children: shortcut.padEnd(7) }),
+    label
+  ] }, `${shortcut}-${label}`))
+] });
+var ShortcutsGrid = () => /* @__PURE__ */ jsxs2(Box3, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [
+  /* @__PURE__ */ jsx5(ShortcutColumn, { title: "Global", items: GLOBAL_SHORTCUTS }),
+  /* @__PURE__ */ jsx5(ShortcutColumn, { title: "Actions", items: ACTION_SHORTCUTS })
+] });
+
+// src/features/tui/ShortcutController.constants.ts
+var GLOBAL_SHORTCUT_PRIORITY = -100;
+var HELP_SHORTCUT_PRIORITY = 100;
+
+// src/app/Navigator.tsx
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+var Navigator = () => {
+  const [shortcutsVisible, setShortcutsVisible] = useState4(false);
+  return /* @__PURE__ */ jsx6(ShortcutProvider, { children: /* @__PURE__ */ jsx6(
+    NavigatorShell,
+    {
+      shortcutsVisible,
+      onToggleShortcuts: () => setShortcutsVisible((visible) => !visible)
+    }
+  ) });
+};
+var NavigatorShell = ({
+  shortcutsVisible,
+  onToggleShortcuts
+}) => {
+  const { exit } = useApp();
+  const navigate = useNavigate2();
+  const location = useLocation3();
+  const atRoot = location.pathname === ROUTES.root();
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (atRoot && (input === "q" || input === "Q")) {
+      exit();
+    }
+  });
+  useShortcutHandler(
+    ({ input }) => {
+      if (input !== "?") return false;
+      onToggleShortcuts();
+      return true;
+    },
+    { priority: HELP_SHORTCUT_PRIORITY }
+  );
+  useShortcutHandler(
+    ({ input }) => {
+      const route = {
+        t: "/tests",
+        r: ROUTES.testRuns.list(),
+        s: "/suites",
+        u: ROUTES.suiteRuns.list(),
+        p: "/project",
+        ",": "/settings"
+      }[input];
+      if (!route) return false;
+      navigate(route);
+      return true;
+    },
+    { priority: GLOBAL_SHORTCUT_PRIORITY }
+  );
+  return /* @__PURE__ */ jsx6(Box4, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx6(AuthGate, { children: (authenticated) => /* @__PURE__ */ jsxs3(
+    EscProvider,
+    {
+      canGoBack: !atRoot,
+      onUnhandled: () => {
+        if (!atRoot) navigate(-1);
+      },
+      children: [
+        /* @__PURE__ */ jsx6(Header, { authenticated }),
+        authenticated && /* @__PURE__ */ jsx6(Breadcrumb, {}),
+        /* @__PURE__ */ jsx6(Outlet, {}),
+        shortcutsVisible && /* @__PURE__ */ jsx6(ShortcutsGrid, {})
+      ]
+    }
+  ) }) });
+};
+
+// src/app/views/logout/Logout.tsx
+import { StatusMessage } from "@inkjs/ui";
+import { useApp as useApp2 } from "ink";
+import { useEffect as useEffect4, useState as useState5 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var Logout = () => {
+  const { exit } = useApp2();
+  const [error, setError] = useState5(null);
+  useEffect4(() => {
+    let cleared;
+    try {
+      ({ cleared } = logout());
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      return;
+    }
+    process.stdout.write(cleared ? "Logged out.\n" : "Already logged out.\n");
+    exit();
+  }, [exit]);
+  return /* @__PURE__ */ jsx7(ViewLayout, { title: "Logout", hintsHidden: true, children: error && /* @__PURE__ */ jsx7(StatusMessage, { variant: "error", children: `Error: ${error}` }) });
+};
+
+// src/app/hooks/useIsUserToken.ts
+var useIsUserToken = () => {
+  const { auth } = useNavigatorSession();
+  const needsIdentity = auth.kind === "ready" && !auth.isUserToken;
+  const query = useFeatureQuery(
+    async () => needsIdentity ? (await getIdentity()).tokenType : null,
+    [needsIdentity, auth.token]
+  );
+  return auth.isUserToken || query.data === "user";
+};
+
+// src/app/views/MainMenu.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var MainMenu = () => {
+  const isUserToken = useIsUserToken();
+  const canSwitchProject = !hasProjectConfigFile();
+  const options = [
+    { label: "Tests", shortcut: "t", description: "Run, list, import tests", to: "/tests" },
+    {
+      label: "Test runs",
+      shortcut: "r",
+      description: "Browse recent test runs",
+      to: ROUTES.testRuns.root()
+    },
+    {
+      label: "Suites",
+      shortcut: "s",
+      description: "Run and list test suites",
+      to: "/suites"
+    },
+    {
+      label: "Suite runs",
+      shortcut: "u",
+      description: "Browse recent suite runs",
+      to: ROUTES.suiteRuns.root()
+    },
+    {
+      label: "Profiles",
+      shortcut: "f",
+      description: "Manage profiles",
+      to: "/profiles"
+    },
+    {
+      label: "Current project",
+      shortcut: "p",
+      description: "Import or export current project",
+      to: "/project"
+    },
+    ...canSwitchProject ? [
+      {
+        label: "Switch project",
+        shortcut: "w",
+        description: "Pick another project for this session",
+        to: "/project/switch"
+      }
+    ] : [],
+    ...isUserToken ? [
+      {
+        label: "Logout",
+        shortcut: "l",
+        description: "Clear the current CLI session",
+        to: "/logout"
+      }
+    ] : []
+  ];
+  return /* @__PURE__ */ jsx8(ViewLayout, { children: /* @__PURE__ */ jsx8(MenuList, { options }) });
+};
+
+// src/app/hooks/useProfiles.ts
+var useProfilesList = () => useFeatureQuery(() => listProfiles(), []);
+
+// src/features/profiles/profiles.utils.ts
+var profileColumns = [
+  { key: "name", label: "Name", width: 36 },
+  { key: "default", label: "Default", width: 10 }
+];
+var getProfileRow = (profile) => ({
+  key: profile.id,
+  cells: {
+    name: profile.name,
+    default: profile.isDefault ? "yes" : "no"
+  },
+  value: profile
+});
+
+// src/features/tui/components/BaseResourceListScreen/BaseResourceListScreen.tsx
+import { Spinner, StatusMessage as StatusMessage2 } from "@inkjs/ui";
+import { Box as Box7 } from "ink";
+import { useState as useState6 } from "react";
+
+// src/features/tui/components/TableList/TableList.tsx
+import { Box as Box6, Text as Text5 } from "ink";
+
+// src/features/tui/components/TableList/TableList.utils.ts
+var fitCell = (value, width) => {
+  const text = value === null || value === void 0 || value === "" ? "-" : String(value);
+  const visible = text.length > width ? `${text.slice(0, Math.max(0, width - 1))}\u2026` : text;
+  return visible.padEnd(width, " ");
+};
+
+// src/features/tui/components/TableList/TableListRow.tsx
+import { Box as Box5, Text as Text4 } from "ink";
+import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+var TableListRow = ({
+  columns,
+  row,
+  selected
+}) => /* @__PURE__ */ jsx9(SelectableOption, { selected, children: ({ color, backgroundColor }) => /* @__PURE__ */ jsxs4(Box5, { children: [
+  /* @__PURE__ */ jsx9(SelectionPrefix, { selected }),
+  columns.map((column, i) => {
+    const sep = i === 0 ? "" : "  ";
+    const cell = row.cells[column.key];
+    if (column.render) {
+      return /* @__PURE__ */ jsxs4(Box5, { children: [
+        sep ? /* @__PURE__ */ jsx9(Text4, { backgroundColor, children: sep }) : null,
+        /* @__PURE__ */ jsx9(Box5, { width: column.width, children: column.render(cell, row, {
+          selected,
+          width: column.width,
+          color,
+          backgroundColor
+        }) })
+      ] }, column.key);
+    }
+    return /* @__PURE__ */ jsxs4(Text4, { color, backgroundColor, children: [
+      sep,
+      fitCell(cell, column.width)
+    ] }, column.key);
+  })
+] }) });
+
+// src/features/tui/components/TableList/TableList.tsx
+import { jsx as jsx10, jsxs as jsxs5 } from "react/jsx-runtime";
+var TableList = ({
+  columns,
+  rows,
+  navigationDisabled = false,
+  onSelect
+}) => /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+  /* @__PURE__ */ jsx10(Box6, { children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+    "  ",
+    columns.map((column) => fitCell(column.label, column.width)).join("  ")
+  ] }) }),
+  /* @__PURE__ */ jsx10(
+    VirtualizedList,
+    {
+      items: rows,
+      reservedTerminalRows: DEFAULT_RESERVED_TERMINAL_ROWS + 1,
+      navigationDisabled,
+      getKey: (row) => row.key,
+      renderItem: (row, _rowIndex, selected) => /* @__PURE__ */ jsx10(TableListRow, { columns, row, selected: !navigationDisabled && selected }),
+      onSelect: (row) => onSelect?.(row)
+    }
+  )
+] });
+
+// src/features/tui/components/BaseResourceListScreen/BaseResourceListScreen.tsx
+import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+var BaseResourceListScreen = ({
+  title,
+  loadingLabel,
+  emptyMessage,
+  resources,
+  isLoading,
+  isError,
+  error,
+  columns,
+  getRow,
+  searchable,
+  query = "",
+  onSearch,
+  onSelectResource
+}) => {
+  const rows = resources ?? [];
+  const [searchMode, setSearchMode] = useState6(false);
+  const handleSelect = (row) => {
+    if (row.value !== void 0 && onSelectResource) onSelectResource(row.value);
+  };
+  return /* @__PURE__ */ jsxs6(
+    ViewLayout,
+    {
+      title: query ? `Search: "${query}"` : title,
+      searchable,
+      onSearch,
+      onSearchModeChange: setSearchMode,
+      children: [
+        isLoading && /* @__PURE__ */ jsx11(Box7, { children: /* @__PURE__ */ jsx11(Spinner, { label: loadingLabel }) }),
+        isError && /* @__PURE__ */ jsx11(StatusMessage2, { variant: "error", children: error }),
+        !isLoading && !isError && rows.length === 0 && !query && /* @__PURE__ */ jsx11(StatusMessage2, { variant: "warning", children: emptyMessage }),
+        !isLoading && !isError && (rows.length > 0 || query) && /* @__PURE__ */ jsx11(
+          TableList,
+          {
+            columns,
+            rows: rows.map(getRow),
+            navigationDisabled: searchMode,
+            onSelect: handleSelect
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/app/views/profiles/ProfilesList.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+var ProfilesList = () => {
+  const request = useProfilesList();
+  return /* @__PURE__ */ jsx12(
+    BaseResourceListScreen,
+    {
+      title: "Profiles",
+      loadingLabel: "Loading profiles...",
+      emptyMessage: "No profiles found",
+      resources: request.data,
+      isLoading: request.isLoading,
+      isError: request.isError,
+      error: request.error,
+      columns: profileColumns,
+      getRow: getProfileRow
+    }
+  );
+};
+
+// src/app/views/profiles/ProfilesMenu.tsx
+import { Spinner as Spinner2 } from "@inkjs/ui";
+import { useEffect as useEffect5 } from "react";
+import { useNavigate as useNavigate3 } from "react-router";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var ProfilesMenu = () => {
+  const navigate = useNavigate3();
+  useEffect5(() => {
+    navigate("/profiles/list", { replace: true });
+  }, [navigate]);
+  return /* @__PURE__ */ jsx13(Spinner2, { label: "Loading..." });
+};
+
+// src/app/views/project/ProjectExport.tsx
+import { Spinner as Spinner3, StatusMessage as StatusMessage3 } from "@inkjs/ui";
+import { useEffect as useEffect6, useState as useState8 } from "react";
+
+// src/app/hooks/useFeatureMutation.ts
+import { useCallback as useCallback3, useRef, useState as useState7 } from "react";
+var useFeatureMutation = (fn) => {
+  const fnRef = useRef(fn);
+  const activeMutationRef = useRef(0);
+  const [state, setState] = useState7({
+    data: void 0,
+    error: void 0,
+    status: "idle"
+  });
+  fnRef.current = fn;
+  const trigger = useCallback3(async (arg) => {
+    const mutationId = activeMutationRef.current + 1;
+    activeMutationRef.current = mutationId;
+    setState({
+      data: void 0,
+      error: void 0,
+      status: "pending"
+    });
+    try {
+      const data = await fnRef.current(arg);
+      if (activeMutationRef.current === mutationId) {
+        setState({ data, error: void 0, status: "fulfilled" });
+      }
+      return { data };
+    } catch (err) {
+      const error = formatErrorMessage(err);
+      if (activeMutationRef.current === mutationId) {
+        setState({ data: void 0, error, status: "rejected" });
+      }
+      return { error };
+    }
+  }, []);
+  return [
+    trigger,
+    {
+      data: state.data,
+      error: state.error,
+      isLoading: state.status === "pending",
+      isSuccess: state.status === "fulfilled",
+      isError: state.status === "rejected"
+    }
+  ];
+};
+
+// src/features/tui/components/TextInput/TextInput.tsx
+import { Box as Box8, Text as Text6 } from "ink";
+import InkTextInput from "ink-text-input";
+import { jsx as jsx14, jsxs as jsxs7 } from "react/jsx-runtime";
+var TextInput = (props) => {
+  useShortcutBlocker();
+  return /* @__PURE__ */ jsxs7(Box8, { children: [
+    /* @__PURE__ */ jsx14(Text6, { color: "cyan", children: "\u203A " }),
+    /* @__PURE__ */ jsx14(InkTextInput, { ...props })
+  ] });
+};
+
+// src/app/views/project/ProjectExport.tsx
+import { jsx as jsx15, jsxs as jsxs8 } from "react/jsx-runtime";
+var ProjectExport = () => {
+  const [outputValue, setOutputValue] = useState8("");
+  const [output, setOutput] = useState8(null);
+  const [exportProjectMutation, exportProjectResult] = useFeatureMutation(
+    (outputPath) => exportProject(outputPath || void 0)
+  );
+  useEffect6(() => {
+    if (output !== null) void exportProjectMutation(output);
+  }, [exportProjectMutation, output]);
+  if (output === null) {
+    return /* @__PURE__ */ jsx15(ViewLayout, { title: "Output file (blank = auto)", hints: "confirm", hintsPosition: "bottom", children: /* @__PURE__ */ jsx15(TextInput, { value: outputValue, onChange: setOutputValue, onSubmit: setOutput }) });
+  }
+  return /* @__PURE__ */ jsxs8(ViewLayout, { hintsHidden: true, children: [
+    exportProjectResult.isLoading && /* @__PURE__ */ jsx15(Spinner3, { label: "Exporting project..." }),
+    exportProjectResult.isError && /* @__PURE__ */ jsx15(StatusMessage3, { variant: "error", children: exportProjectResult.error }),
+    exportProjectResult.data && /* @__PURE__ */ jsx15(StatusMessage3, { variant: "success", children: `Exported project to ${exportProjectResult.data.outPath} (${exportProjectResult.data.size} bytes)` })
+  ] });
+};
+
+// src/app/views/project/ProjectImport.tsx
+import { Spinner as Spinner4, StatusMessage as StatusMessage4 } from "@inkjs/ui";
+import { useEffect as useEffect7, useState as useState10 } from "react";
+import { useNavigate as useNavigate4 } from "react-router";
+
+// src/features/tui/components/FilePicker/FilePicker.tsx
+import { readdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { Box as Box9, Text as Text7 } from "ink";
+import { useMemo, useState as useState9 } from "react";
+
+// src/utils/filePicker.ts
+import { extname } from "path";
+var toFilePickerItems = (entries, allowedExtensions) => {
+  const normalizedExtensions = new Set(
+    allowedExtensions.map((extension) => extension.toLowerCase())
+  );
+  return entries.filter((entry) => {
+    if (entry.isDirectory()) return true;
+    return normalizedExtensions.has(extname(entry.name).toLowerCase());
+  }).map((entry) => {
+    const type = entry.isDirectory() ? "directory" : "file";
+    return {
+      key: `${type === "directory" ? "dir" : "file"}:${entry.name}`,
+      label: type === "directory" ? `${entry.name}/` : entry.name,
+      name: entry.name,
+      type
+    };
+  }).sort((left, right) => {
+    if (left.type !== right.type) return left.type === "directory" ? -1 : 1;
+    return left.name.localeCompare(right.name);
+  });
+};
+
+// src/features/tui/components/FilePicker/FilePicker.tsx
+import { jsx as jsx16, jsxs as jsxs9 } from "react/jsx-runtime";
+var FilePicker = ({
+  label,
+  extensions,
+  initialDir = userCwd(),
+  onSubmit,
+  onBack
+}) => {
+  const [currentDir, setCurrentDir] = useState9(() => resolve(userCwd(), initialDir));
+  useEscHandler(() => {
+    onBack();
+    return true;
+  });
+  const { items, error } = useMemo(() => {
+    try {
+      const entries = readdirSync(currentDir, { withFileTypes: true });
+      const pickerItems = toFilePickerItems(entries, extensions);
+      const parent = dirname(currentDir);
+      const allItems = parent === currentDir ? pickerItems : [
+        {
+          key: "dir:..",
+          label: "../",
+          name: "..",
+          type: "directory"
+        },
+        ...pickerItems
+      ];
+      return { items: allItems, error: null };
+    } catch (err) {
+      return {
+        items: [],
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }, [currentDir, extensions]);
+  const handleSelect = (item) => {
+    const selected = item.value;
+    if (!selected) return;
+    if (selected.type === "directory") {
+      setCurrentDir((dir) => resolve(dir, selected.name));
+      return;
+    }
+    onSubmit(join(currentDir, selected.name));
+  };
+  return /* @__PURE__ */ jsx16(Box9, { flexDirection: "column", children: /* @__PURE__ */ jsxs9(ViewLayout, { title: `${label}: ${currentDir}`, hints: "navigationOpenSelect", children: [
+    /* @__PURE__ */ jsx16(
+      MenuList,
+      {
+        options: items.map((item) => ({ label: item.label, value: item })),
+        onSelect: handleSelect
+      },
+      currentDir
+    ),
+    items.length === 0 && /* @__PURE__ */ jsx16(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text7, { dimColor: true, children: "No matching files in this directory." }) }),
+    error && /* @__PURE__ */ jsx16(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text7, { color: "red", children: error }) })
+  ] }) });
+};
+
+// src/app/views/project/ProjectImport.tsx
+import { jsx as jsx17, jsxs as jsxs10 } from "react/jsx-runtime";
+var ProjectImport = () => {
+  const navigate = useNavigate4();
+  const [file, setFile] = useState10(null);
+  const [importProjectMutation, importProjectResult] = useFeatureMutation(importProject);
+  useEffect7(() => {
+    if (file) importProjectMutation(file);
+  }, [file, importProjectMutation]);
+  if (!file) {
+    return /* @__PURE__ */ jsx17(
+      FilePicker,
+      {
+        label: "Select .zip file",
+        extensions: [".zip"],
+        onSubmit: setFile,
+        onBack: () => navigate(-1)
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs10(ViewLayout, { hintsHidden: true, children: [
+    importProjectResult.isLoading && /* @__PURE__ */ jsx17(Spinner4, { label: `Importing project from ${file}...` }),
+    importProjectResult.isError && /* @__PURE__ */ jsx17(StatusMessage4, { variant: "error", children: importProjectResult.error }),
+    importProjectResult.data && /* @__PURE__ */ jsx17(StatusMessage4, { variant: "success", children: `Project import started from ${importProjectResult.data.path} (${importProjectResult.data.size} bytes)` })
+  ] });
+};
+
+// src/app/views/project/ProjectInit.tsx
+import { useApp as useApp3 } from "ink";
+import { useEffect as useEffect8, useState as useState12 } from "react";
+import { useLocation as useLocation4, useNavigate as useNavigate5 } from "react-router";
+
+// src/app/components/ProjectPicker/ProjectPicker.tsx
+import { Spinner as Spinner5, StatusMessage as StatusMessage5 } from "@inkjs/ui";
+import { jsx as jsx18, jsxs as jsxs11 } from "react/jsx-runtime";
+var ProjectPicker = ({ onSelect, currentProjectId }) => {
+  const projectsQuery = useFeatureQuery(listProjects, []);
+  const projects = projectsQuery.data ?? [];
+  return /* @__PURE__ */ jsxs11(ViewLayout, { title: "Choose BugBug project", hints: "navigationSelect", children: [
+    projectsQuery.isLoading && /* @__PURE__ */ jsx18(Spinner5, { label: "Loading projects..." }),
+    projectsQuery.isError && /* @__PURE__ */ jsx18(StatusMessage5, { variant: "error", children: `Error: ${projectsQuery.error ?? "Unknown error"}` }),
+    !projectsQuery.isLoading && !projectsQuery.isError && projects.length === 0 && /* @__PURE__ */ jsx18(StatusMessage5, { variant: "warning", children: "No projects found" }),
+    !projectsQuery.isLoading && !projectsQuery.isError && projects.length > 0 && /* @__PURE__ */ jsx18(
+      MenuList,
+      {
+        options: projects.map((project) => ({
+          key: project.id,
+          label: project.id === currentProjectId ? ` ${project.name} (current)` : ` ${project.name}`,
+          value: project
+        })),
+        onSelect: (item) => {
+          if (item.value) onSelect(item.value);
+        }
+      }
+    )
+  ] });
+};
+
+// src/app/views/project/ProjectInitAuth.tsx
+import { StatusMessage as StatusMessage6 } from "@inkjs/ui";
+import { useState as useState11 } from "react";
+import { jsx as jsx19, jsxs as jsxs12 } from "react/jsx-runtime";
+var ProjectInitAuth = ({
+  onTokenReceive,
+  onTokenError,
+  message
+}) => {
+  const [method, setMethod] = useState11("choose");
+  const [tokenInput, setTokenInput] = useState11("");
+  const handleLogin = () => {
+    void (async () => {
+      try {
+        const { token } = await login();
+        updateSdkConfig({ apiToken: token });
+        onTokenReceive(token, { isUserToken: true });
+      } catch (err) {
+        onTokenError(err instanceof Error ? err.message : String(err));
+      }
+    })();
+  };
+  const handleTokenSubmit = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      onTokenError("Token must not be empty.");
+      return;
+    }
+    try {
+      updateSdkConfig({ apiToken: trimmed });
+      onTokenReceive(trimmed, { isUserToken: false });
+    } catch (err) {
+      onTokenError(err instanceof Error ? err.message : String(err));
+    }
+  };
+  if (method === "token") {
+    return /* @__PURE__ */ jsx19(EscProvider, { onUnhandled: () => setMethod("choose"), children: /* @__PURE__ */ jsxs12(ViewLayout, { title: "BugBug project API token", hints: "confirm", hintsPosition: "bottom", children: [
+      /* @__PURE__ */ jsx19(
+        TextInput,
+        {
+          value: tokenInput,
+          onChange: setTokenInput,
+          onSubmit: handleTokenSubmit,
+          mask: "*"
+        }
+      ),
+      message && /* @__PURE__ */ jsx19(StatusMessage6, { variant: "error", children: `Error: ${message}` })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs12(ViewLayout, { title: "How do you want to authenticate?", hints: "navigationSelect", children: [
+    /* @__PURE__ */ jsx19(
+      MenuList,
+      {
+        options: [
+          {
+            label: "Login using BugBug",
+            description: "Authenticate via BugBug and use your user token",
+            value: "login"
+          },
+          {
+            label: "Set API Token",
+            description: "Paste a project or organization API token",
+            value: "token"
+          }
+        ],
+        onSelect: (item) => {
+          if (item.value === "login") handleLogin();
+          else setMethod("token");
+        }
+      }
+    ),
+    message && /* @__PURE__ */ jsx19(StatusMessage6, { variant: "error", children: `Error: ${message}` })
+  ] });
+};
+
+// src/app/views/project/ProjectInit.tsx
+import { jsx as jsx20, jsxs as jsxs13 } from "react/jsx-runtime";
+var ProjectInit = () => {
+  const { exit } = useApp3();
+  const navigate = useNavigate5();
+  const location = useLocation4();
+  const state = location.state;
+  const redirectUrl = state?.redirectUrl ?? "/";
+  const onlyThisSession = state?.onlyThisSession ?? false;
+  const ignoreConfiguredAuth = state?.ignoreConfiguredAuth ?? false;
+  const { auth, config, authError, completeSession } = useNavigatorSession();
+  const [token, setToken] = useState12(
+    ignoreConfiguredAuth ? null : auth.token ?? null
+  );
+  const [usingUserToken, setUsingUserToken] = useState12(false);
+  const [error, setError] = useState12(null);
+  useEffect8(() => {
+    if (auth.kind !== "ready" || ignoreConfiguredAuth) return;
+    if (onlyThisSession) {
+      navigate(redirectUrl, { replace: true });
+    }
+  }, [auth.kind, ignoreConfiguredAuth, navigate, redirectUrl, onlyThisSession, exit]);
+  const handleTokenReceive = (newToken, { isUserToken }) => {
+    setError(null);
+    setUsingUserToken(isUserToken);
+    setToken(newToken);
+  };
+  const handleTokenError = (errorMessage) => {
+    setError(errorMessage);
+  };
+  const handleProjectSelectAndFinish = (project) => {
+    if (!token) return;
+    if (usingUserToken) switchProject(project.id, { currentProjectId: config.projectId });
+    const completeProjectSession = () => {
+      if (usingUserToken) completeSession(token, project.id, { isUserToken: true });
+      else completeSession(token, project.id);
+    };
+    if (onlyThisSession) {
+      completeProjectSession();
+      navigate(redirectUrl, { replace: true });
+      return;
+    }
+    (async () => {
+      try {
+        await initProject(token, project.id);
+        completeProjectSession();
+        exit();
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+      }
+    })();
+  };
+  const message = error ?? authError;
+  return /* @__PURE__ */ jsxs13(EscProvider, { onUnhandled: exit, children: [
+    !token && /* @__PURE__ */ jsx20(
+      ProjectInitAuth,
+      {
+        onTokenReceive: handleTokenReceive,
+        onTokenError: handleTokenError,
+        message
+      }
+    ),
+    token && /* @__PURE__ */ jsx20(ProjectPicker, { onSelect: handleProjectSelectAndFinish, currentProjectId: auth.projectId })
+  ] });
+};
+
+// src/app/views/project/ProjectMenu.tsx
+import { jsx as jsx21 } from "react/jsx-runtime";
+var ProjectMenu = () => {
+  const canSwitchProject = !hasProjectConfigFile();
+  return /* @__PURE__ */ jsx21(ViewLayout, { children: /* @__PURE__ */ jsx21(
+    MenuList,
+    {
+      options: [
+        { label: "Export project (ZIP)", shortcut: "e", to: "/project/export" },
+        ...canSwitchProject ? [{ label: "Import project (ZIP)", shortcut: "i", to: "/project/import" }] : []
+      ]
+    }
+  ) });
+};
+
+// src/app/views/project/ProjectSwitch.tsx
+import { useNavigate as useNavigate6 } from "react-router";
+import { jsx as jsx22 } from "react/jsx-runtime";
+var ProjectSwitch = () => {
+  const navigate = useNavigate6();
+  const { config, setSessionProject } = useNavigatorSession();
+  const handleSelect = (project) => {
+    switchProject(project.id, { currentProjectId: config.projectId });
+    setSessionProject(project.id);
+    navigate("/", { replace: true });
+  };
+  return /* @__PURE__ */ jsx22(ProjectPicker, { onSelect: handleSelect, currentProjectId: config.projectId });
+};
+
+// src/app/views/settings/SettingsMenu.tsx
+import { jsx as jsx23 } from "react/jsx-runtime";
+var SettingsMenu = () => {
+  const isUserToken = useIsUserToken();
+  const options = [
+    {
+      label: `Set current session token`,
+      shortcut: "t",
+      to: "/settings/setSessionToken"
+    },
+    ...isUserToken ? [
+      {
+        label: "Logout",
+        to: "/logout"
+      }
+    ] : []
+  ];
+  return /* @__PURE__ */ jsx23(ViewLayout, { children: /* @__PURE__ */ jsx23(MenuList, { options }) });
+};
+
+// src/app/views/settings/SettingsSetSessionToken.tsx
+import { StatusMessage as StatusMessage7 } from "@inkjs/ui";
+import { useState as useState13 } from "react";
+import { jsx as jsx24, jsxs as jsxs14 } from "react/jsx-runtime";
+var SettingsSetSessionToken = () => {
+  const { auth, completeSession } = useNavigatorSession();
+  const [tokenValue, setTokenValue] = useState13("");
+  const [token, setToken] = useState13(null);
+  const [error, setError] = useState13(null);
+  const [saved, setSaved] = useState13(false);
+  const handleTokenSubmit = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      setError("Token must not be empty.");
+      return;
+    }
+    try {
+      updateSdkConfig({ apiToken: trimmed });
+      setError(null);
+      setSaved(false);
+      setToken(trimmed);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  };
+  const handleProjectSelect = (project) => {
+    if (!token) return;
+    completeSession(token, project.id);
+    setSaved(true);
+  };
+  if (token === null) {
+    return /* @__PURE__ */ jsxs14(ViewLayout, { title: "Project API token", hints: "confirm", hintsPosition: "bottom", children: [
+      /* @__PURE__ */ jsx24(
+        TextInput,
+        {
+          value: tokenValue,
+          onChange: setTokenValue,
+          onSubmit: handleTokenSubmit,
+          mask: "*"
+        }
+      ),
+      error && /* @__PURE__ */ jsx24(StatusMessage7, { variant: "error", children: `Error: ${error}` })
+    ] });
+  }
+  if (!saved) {
+    return /* @__PURE__ */ jsx24(ProjectPicker, { onSelect: handleProjectSelect, currentProjectId: auth.projectId });
+  }
+  return /* @__PURE__ */ jsx24(ViewLayout, { hintsHidden: true, children: /* @__PURE__ */ jsx24(StatusMessage7, { variant: "success", children: "Token saved and valid only for this session" }) });
+};
+
+// src/app/views/suiteRuns/SuiteRunDetails.tsx
+import { Spinner as Spinner6, StatusMessage as StatusMessage8 } from "@inkjs/ui";
+import { Text as Text8 } from "ink";
+import { useLocation as useLocation5, useParams } from "react-router";
+
+// src/app/hooks/useSuiteRuns.ts
+var useSuiteRunsList = () => useFeatureQuery(() => listSuiteRuns(), []);
+var useSuiteRunDetails = (runId) => useFeatureQuery(async () => {
+  if (!runId) return void 0;
+  return getSuiteRunDetails(runId);
+}, [runId]);
+
+// src/features/suiteRuns/suiteRuns.utils.ts
+var getSuiteRunName = (run) => run.name || run.id;
+
+// src/app/views/suiteRuns/SuiteRunDetails.tsx
+import { jsx as jsx25, jsxs as jsxs15 } from "react/jsx-runtime";
+var SuiteRunDetails = () => {
+  const { runId } = useParams();
+  const location = useLocation5();
+  const state = location.state;
+  const request = useSuiteRunDetails(runId);
+  const title = request.data ? getSuiteRunName(request.data) : state?.suiteRunName;
+  const menuState = title ? { suiteRunName: title } : void 0;
+  if (!request.data || !runId) {
+    return /* @__PURE__ */ jsxs15(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+      request.isLoading && /* @__PURE__ */ jsx25(Spinner6, { label: "Loading suite run..." }),
+      request.isError && /* @__PURE__ */ jsx25(StatusMessage8, { variant: "error", children: request.error }),
+      !request.isLoading && !request.isError && !request.data && /* @__PURE__ */ jsx25(Text8, { color: "yellow", children: "Suite run not found." })
+    ] });
+  }
+  return /* @__PURE__ */ jsx25(BaseSuiteRunDetails, { runId, title, menuState });
+};
+
+// src/app/views/suiteRuns/SuiteRunOpen.tsx
+import { Spinner as Spinner7, StatusMessage as StatusMessage9 } from "@inkjs/ui";
+import { Box as Box10, Text as Text9 } from "ink";
+import { useEffect as useEffect9 } from "react";
+import { useLocation as useLocation6, useParams as useParams2 } from "react-router";
+import { Fragment as Fragment2, jsx as jsx26, jsxs as jsxs16 } from "react/jsx-runtime";
+var WebUrlUnavailableMessage = () => /* @__PURE__ */ jsx26(StatusMessage9, { variant: "warning", children: "No web URL available for this run" });
+var OpenSuiteRun = ({ url }) => {
+  const [openSuiteRun, openSuiteRunResult] = useFeatureMutation(async (url2) => {
+    await openExternalUrl(url2);
+    return url2;
+  });
+  useEffect9(() => {
+    if (url) void openSuiteRun(url);
+  }, [openSuiteRun, url]);
+  if (!url) return /* @__PURE__ */ jsx26(WebUrlUnavailableMessage, {});
+  return /* @__PURE__ */ jsxs16(Fragment2, { children: [
+    openSuiteRunResult.isLoading && /* @__PURE__ */ jsx26(Spinner7, { label: "Opening BugBug..." }),
+    openSuiteRunResult.isError && /* @__PURE__ */ jsx26(StatusMessage9, { variant: "error", children: openSuiteRunResult.error }),
+    openSuiteRunResult.data && /* @__PURE__ */ jsxs16(Box10, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx26(StatusMessage9, { variant: "success", children: "Opened in BugBug" }),
+      /* @__PURE__ */ jsx26(Text9, { dimColor: true, children: openSuiteRunResult.data })
+    ] })
+  ] });
+};
+var SuiteRunOpen = () => {
+  const { runId } = useParams2();
+  const location = useLocation6();
+  const state = location.state;
+  const request = useSuiteRunDetails(runId);
+  const title = request.data ? getSuiteRunName(request.data) : state?.suiteRunName ?? runId;
+  return /* @__PURE__ */ jsxs16(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+    request.isLoading && /* @__PURE__ */ jsx26(Spinner7, { label: "Loading..." }),
+    request.isError && /* @__PURE__ */ jsx26(Text9, { color: "red", children: request.error }),
+    !request.isLoading && !request.isError && /* @__PURE__ */ jsx26(OpenSuiteRun, { url: request.data?.webappUrl })
+  ] });
+};
+
+// src/app/views/suiteRuns/SuiteRunShowTestRuns.tsx
+import { Spinner as Spinner8 } from "@inkjs/ui";
+import { StatusMessage as StatusMessage10 } from "@inkjs/ui";
+import { useLocation as useLocation7, useParams as useParams3 } from "react-router";
+
+// src/features/testRuns/components/TestRunsList.tsx
+import { useNavigate as useNavigate7 } from "react-router";
+
+// src/features/testRuns/testRuns.utils.ts
+var getTestRunName = (run) => run.name || run.id;
+var DEBUG_ARTIFACT_LABELS = {
+  logs_partial: "Download partial test run logs",
+  logs: "Download test run logs",
+  cloud_logs: "Download cloud logs",
+  container_stats: "Download container stats",
+  chrome_debug_logs: "Download Chrome debug logs",
+  network_logs: "Download network logs (HAR)",
+  dom_snapshot: "Show DOM snapshot"
+};
+var getDebugArtifactLabel = (artifact) => DEBUG_ARTIFACT_LABELS[artifact.kind];
+
+// src/features/testRuns/components/TestRunsList.constants.tsx
+import { jsx as jsx27 } from "react/jsx-runtime";
+var TEST_RUN_LIST_COLUMNS = [
+  { key: "name", label: "Name", width: 30 },
+  { key: "duration", label: "Duration", width: 8 },
+  { key: "profileName", label: "Profile", width: 8 },
+  { key: "triggeredBy", label: "Run by", width: 8 },
+  { key: "errorCode", label: "Error", width: 20 },
+  {
+    key: "status",
+    label: "Status",
+    width: 15,
+    render: (_cell, row, ctx) => /* @__PURE__ */ jsx27(
+      Status,
+      {
+        status: row.value?.status,
+        autoRetried: row.value?.isAutoRetried,
+        color: ctx.color,
+        backgroundColor: ctx.backgroundColor
+      }
+    )
+  }
+];
+
+// src/features/testRuns/components/TestRunsList.utils.tsx
+var getTestRunRow = (run) => {
+  return {
+    key: run.id,
+    cells: {
+      name: getTestRunName(run),
+      status: run.status ?? "",
+      errorCode: run.errorCode ?? "",
+      profileName: run.profileName ?? "",
+      screenSizeType: run.screenSizeType ?? "",
+      triggeredBy: run.triggeredBy ?? "",
+      duration: formatDuration(run.duration, { started: run.started, ended: run.ended })
+    },
+    value: run
+  };
+};
+
+// src/features/testRuns/components/TestRunsList.tsx
+import { jsx as jsx28 } from "react/jsx-runtime";
+var TestRunsList = ({
+  title,
+  loadingLabel = "Loading test runs...",
+  emptyMessage = "No test runs found",
+  testRuns,
+  isLoading,
+  isError,
+  error
+}) => {
+  const navigate = useNavigate7();
+  return /* @__PURE__ */ jsx28(
+    BaseResourceListScreen,
+    {
+      title,
+      loadingLabel,
+      emptyMessage,
+      resources: testRuns,
+      isLoading,
+      isError,
+      error,
+      columns: TEST_RUN_LIST_COLUMNS,
+      getRow: getTestRunRow,
+      onSelectResource: (run) => navigate(ROUTES.testRuns.details(run.id), { state: { testRunName: getTestRunName(run) } })
+    }
+  );
+};
+
+// src/app/views/suiteRuns/SuiteRunShowTestRuns.tsx
+import { jsx as jsx29, jsxs as jsxs17 } from "react/jsx-runtime";
+var SuiteRunTestRuns = ({ run, title }) => {
+  const request = useFeatureQuery(() => getSuiteRunTestRuns(run.id), [run.id]);
+  return /* @__PURE__ */ jsx29(
+    TestRunsList,
+    {
+      title,
+      loadingLabel: `Loading test runs for ${getSuiteRunName(run)}...`,
+      emptyMessage: "No test runs available",
+      testRuns: request.data,
+      isLoading: request.isLoading,
+      isError: request.isError,
+      error: request.error
+    }
+  );
+};
+var SuiteRunShowTestRuns = () => {
+  const { runId } = useParams3();
+  const location = useLocation7();
+  const state = location.state;
+  const request = useSuiteRunDetails(runId);
+  const title = request.data ? `Test runs in "${getSuiteRunName(request.data)}"` : state?.suiteRunName ? `Test runs in "${state.suiteRunName}"` : void 0;
+  if (!request.data) {
+    return /* @__PURE__ */ jsxs17(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+      request.isLoading && /* @__PURE__ */ jsx29(Spinner8, { label: "Loading..." }),
+      request.isError && /* @__PURE__ */ jsx29(StatusMessage10, { variant: "error", children: request.error }),
+      !request.isLoading && !request.isError && /* @__PURE__ */ jsx29(StatusMessage10, { variant: "warning", children: "No test runs available" })
+    ] });
+  }
+  return /* @__PURE__ */ jsx29(SuiteRunTestRuns, { run: request.data, title: title ?? "" });
+};
+
+// src/app/views/suiteRuns/SuiteRunsList.tsx
+import { useNavigate as useNavigate8 } from "react-router";
+
+// src/app/views/suiteRuns/SuiteRunsList.constants.tsx
+import { jsx as jsx30 } from "react/jsx-runtime";
+var SUITE_RUN_LIST_COLUMNS = [
+  { key: "name", label: "Name", width: 30 },
+  { key: "duration", label: "Duration", width: 10 },
+  { key: "profileName", label: "Profile", width: 8 },
+  { key: "triggeredBy", label: "Run by", width: 10 },
+  { key: "result", label: "Result", width: 14 },
+  {
+    key: "status",
+    label: "Status",
+    width: 10,
+    render: (_cell, row, ctx) => /* @__PURE__ */ jsx30(Status, { status: row.value?.status, color: ctx.color, backgroundColor: ctx.backgroundColor })
+  }
+];
+
+// src/app/views/suiteRuns/SuiteRunsList.utils.tsx
+var getSuiteRunResult = (run) => {
+  const testRuns = run.testRuns ?? [];
+  if (testRuns.length === 0) return "";
+  const passed = testRuns.filter((testRun) => testRun.status === "passed").length;
+  return `${passed}/${testRuns.length} passed`;
+};
+var getSuiteRunRow = (run) => {
+  return {
+    key: run.id,
+    cells: {
+      name: getSuiteRunName(run),
+      status: run.status ?? "",
+      result: getSuiteRunResult(run),
+      profileName: run.profileName ?? "",
+      runMode: run.runMode ?? "",
+      triggeredBy: run.triggeredBy ?? "",
+      duration: formatDuration(run.duration, { started: run.started, ended: run.ended })
+    },
+    value: run
+  };
+};
+
+// src/app/views/suiteRuns/SuiteRunsList.tsx
+import { jsx as jsx31 } from "react/jsx-runtime";
+var SuiteRunsList = () => {
+  const navigate = useNavigate8();
+  const request = useSuiteRunsList();
+  return /* @__PURE__ */ jsx31(
+    BaseResourceListScreen,
+    {
+      loadingLabel: "Loading suite runs...",
+      emptyMessage: "No suite runs found",
+      resources: request.data,
+      isLoading: request.isLoading,
+      isError: request.isError,
+      error: request.error,
+      columns: SUITE_RUN_LIST_COLUMNS,
+      getRow: getSuiteRunRow,
+      onSelectResource: (run) => navigate(ROUTES.suiteRuns.details(run.id), {
+        state: { suiteRunName: getSuiteRunName(run) }
+      })
+    }
+  );
+};
+
+// src/app/views/suiteRuns/SuiteRunsMenu.tsx
+import { useEffect as useEffect10 } from "react";
+import { useNavigate as useNavigate9 } from "react-router";
+var SuiteRunsMenu = () => {
+  const navigate = useNavigate9();
+  useEffect10(() => {
+    navigate(ROUTES.suiteRuns.list(), { replace: true });
+  }, [navigate]);
+  return null;
+};
+
+// src/app/views/suites/RunSuite.tsx
+import { useNavigate as useNavigate10 } from "react-router";
+
+// src/app/views/suites/BaseSuitesList.tsx
+import { useState as useState14 } from "react";
+
+// src/app/hooks/useSuites.ts
+var useSuitesList = (query) => useFeatureQuery(() => loadSuiteTableResources(query), [query]);
+var useSuiteDetails = (suiteId) => useFeatureQuery(async () => {
+  if (!suiteId) return void 0;
+  return getSuiteDetails(suiteId);
+}, [suiteId]);
+
+// src/features/suites/suites.constants.tsx
+import { jsx as jsx32 } from "react/jsx-runtime";
+var SUITE_COLUMNS = [
+  { key: "name", label: "Name", width: 42 },
+  {
+    key: "status",
+    label: "Status",
+    width: 14,
+    render: (_cell, row, ctx) => /* @__PURE__ */ jsx32(Status, { status: row.value?.status, color: ctx.color, backgroundColor: ctx.backgroundColor })
+  }
+];
+
+// src/features/suites/suites.utils.tsx
+var getSuiteRow = (suite) => ({
+  key: suite.id,
+  cells: {
+    name: getSuiteName(suite),
+    status: formatRunStatus(suite.status)
+  },
+  value: suite
+});
+var getSuiteName = (suite) => suite.name || suite.id || "Untitled";
+
+// src/app/views/suites/BaseSuitesList.tsx
+import { jsx as jsx33 } from "react/jsx-runtime";
+var BaseSuitesList = ({
+  title,
+  emptyMessage = "No suites found",
+  onSelectSuite
+}) => {
+  const [query, setQuery] = useState14("");
+  const request = useSuitesList(query);
+  return /* @__PURE__ */ jsx33(
+    BaseResourceListScreen,
+    {
+      title,
+      loadingLabel: "Loading suites...",
+      emptyMessage,
+      resources: request.data,
+      isLoading: request.isLoading,
+      isError: request.isError,
+      error: request.error,
+      columns: SUITE_COLUMNS,
+      getRow: getSuiteRow,
+      searchable: true,
+      query,
+      onSearch: (next) => setQuery(next.trim()),
+      onSelectResource: onSelectSuite
+    }
+  );
+};
+
+// src/app/views/suites/RunSuite.tsx
+import { jsx as jsx34 } from "react/jsx-runtime";
+var RunSuite = () => {
+  const navigate = useNavigate10();
+  return /* @__PURE__ */ jsx34(
+    BaseSuitesList,
+    {
+      title: "Select a suite to run:",
+      emptyMessage: "No suites available",
+      onSelectSuite: (suite) => navigate(ROUTES.suites.run(suite.id))
+    }
+  );
+};
+
+// src/app/views/suites/SuiteDetails.tsx
+import { Spinner as Spinner9, StatusMessage as StatusMessage11 } from "@inkjs/ui";
+import { Box as Box11 } from "ink";
+import { useLocation as useLocation8, useParams as useParams4 } from "react-router";
+import { jsx as jsx35, jsxs as jsxs18 } from "react/jsx-runtime";
+var SuiteDetails = () => {
+  const { suiteId } = useParams4();
+  const location = useLocation8();
+  const state = location.state;
+  const request = useSuiteDetails(suiteId);
+  const title = request.data ? getSuiteName(request.data) : state?.suiteName;
+  const detailsState = title ? { suiteName: title } : void 0;
+  const data = request.data;
+  const isNotFound = !request.isLoading && !request.isError && data === void 0;
+  const isReady = !request.isLoading && !request.isError && data !== void 0;
+  const hints = isReady ? void 0 : "none";
+  const options = [
+    {
+      label: "Run",
+      shortcut: "r",
+      description: "Start a fresh run of this suite",
+      to: ROUTES.suites.run(suiteId ?? ""),
+      state: detailsState
+    },
+    {
+      label: "Show last run",
+      shortcut: "h",
+      description: "View the most recent run for this suite",
+      to: ROUTES.suites.lastRun(suiteId ?? ""),
+      state: detailsState
+    },
+    {
+      label: "Open in BugBug",
+      shortcut: "o",
+      description: "Open the suite page in your browser",
+      to: ROUTES.suites.open(suiteId ?? "")
+    }
+  ];
+  return /* @__PURE__ */ jsxs18(ViewLayout, { title, hints, children: [
+    request.isLoading && /* @__PURE__ */ jsx35(Box11, { children: /* @__PURE__ */ jsx35(Spinner9, { label: "Loading suite..." }) }),
+    request.isError && /* @__PURE__ */ jsx35(StatusMessage11, { variant: "error", children: request.error }),
+    isNotFound && /* @__PURE__ */ jsx35(StatusMessage11, { variant: "warning", children: "Suite not found" }),
+    isReady && /* @__PURE__ */ jsx35(MenuList, { options })
+  ] });
+};
+
+// src/app/views/suites/SuiteDetailsLastRun.tsx
+import { Spinner as Spinner10, StatusMessage as StatusMessage12 } from "@inkjs/ui";
+import { Text as Text10 } from "ink";
+import { useLocation as useLocation9, useParams as useParams5 } from "react-router";
+import { jsx as jsx36, jsxs as jsxs19 } from "react/jsx-runtime";
+var SuiteDetailsLastRun = () => {
+  const { suiteId } = useParams5();
+  const location = useLocation9();
+  const state = location.state;
+  const request = useSuiteDetails(suiteId);
+  const suite = request.data;
+  const isReady = !request.isLoading && !request.isError;
+  const title = suite ? getSuiteName(suite) : state?.suiteName ?? suiteId;
+  if (!isReady || !suite?.lastRunId) {
+    return /* @__PURE__ */ jsxs19(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+      request.isLoading && /* @__PURE__ */ jsx36(Spinner10, { label: "Loading..." }),
+      request.isError && /* @__PURE__ */ jsx36(Text10, { color: "red", children: request.error }),
+      isReady && !suite?.lastRunId && /* @__PURE__ */ jsx36(StatusMessage12, { variant: "warning", children: `No previous run found for ${suite ? getSuiteName(suite) : suiteId ?? "suite"}` })
+    ] });
+  }
+  return /* @__PURE__ */ jsx36(
+    BaseSuiteRunDetails,
+    {
+      runId: suite.lastRunId,
+      title,
+      menuState: { suiteRunName: title }
+    }
+  );
+};
+
+// src/app/views/suites/SuiteDetailsOpen.tsx
+import { StatusMessage as StatusMessage13 } from "@inkjs/ui";
+import { Spinner as Spinner11 } from "@inkjs/ui";
+import { Box as Box12, Text as Text11 } from "ink";
+import { useEffect as useEffect11 } from "react";
+import { useParams as useParams6 } from "react-router";
+import { jsx as jsx37, jsxs as jsxs20 } from "react/jsx-runtime";
+var WebUrlUnavailableMessage2 = () => /* @__PURE__ */ jsx37(StatusMessage13, { variant: "warning", children: "No web URL available for this suite" });
+var SuiteDetailsOpen = () => {
+  const { suiteId } = useParams6();
+  const request = useFeatureQuery(async () => {
+    if (!suiteId) return void 0;
+    return getSuite(suiteId);
+  }, [suiteId]);
+  const url = request.data?.webappUrl;
+  const isReady = !request.isLoading && !request.isError;
+  const [openSuite, openSuiteResult] = useFeatureMutation(async (url2) => {
+    await openExternalUrl(url2);
+    return url2;
+  });
+  useEffect11(() => {
+    if (isReady && url) void openSuite(url);
+  }, [isReady, openSuite, url]);
+  return /* @__PURE__ */ jsxs20(ViewLayout, { hintsHidden: true, children: [
+    request.isLoading && /* @__PURE__ */ jsx37(Spinner11, { label: "Loading..." }),
+    request.isError && /* @__PURE__ */ jsx37(Text11, { color: "red", children: request.error }),
+    isReady && !url && /* @__PURE__ */ jsx37(WebUrlUnavailableMessage2, {}),
+    isReady && url && openSuiteResult.isLoading && /* @__PURE__ */ jsx37(Spinner11, { label: "Opening BugBug..." }),
+    isReady && url && openSuiteResult.isError && /* @__PURE__ */ jsx37(StatusMessage13, { variant: "error", children: openSuiteResult.error }),
+    isReady && url && openSuiteResult.data && /* @__PURE__ */ jsxs20(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx37(StatusMessage13, { variant: "success", children: "Opened in BugBug" }),
+      /* @__PURE__ */ jsx37(Text11, { dimColor: true, children: openSuiteResult.data })
+    ] })
+  ] });
+};
+
+// src/app/views/suites/SuiteDetailsRun.tsx
+import { Spinner as Spinner12, StatusMessage as StatusMessage14 } from "@inkjs/ui";
+import { useEffect as useEffect12 } from "react";
+import { useLocation as useLocation10, useNavigate as useNavigate11, useParams as useParams7 } from "react-router";
+import { jsx as jsx38, jsxs as jsxs21 } from "react/jsx-runtime";
+var SuiteDetailsRun = () => {
+  const { suiteId } = useParams7();
+  const location = useLocation10();
+  const navigate = useNavigate11();
+  const state = location.state;
+  const title = state?.suiteName ?? suiteId;
+  const [runSuiteMutation, runSuiteResult] = useFeatureMutation((id) => runSuite(id, {}));
+  useEffect12(() => {
+    if (!suiteId) return;
+    const startRun = async () => {
+      try {
+        const result = await runSuiteMutation(suiteId);
+        if ("data" in result) {
+          navigate(ROUTES.suites.lastRun(suiteId), { replace: true, state });
+        }
+      } catch {
+      }
+    };
+    startRun();
+  }, [navigate, runSuiteMutation, state, suiteId]);
+  if (!runSuiteResult.data) {
+    return /* @__PURE__ */ jsxs21(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+      runSuiteResult.isError && /* @__PURE__ */ jsx38(StatusMessage14, { variant: "error", children: runSuiteResult.error }),
+      !runSuiteResult.isError && /* @__PURE__ */ jsx38(Spinner12, { label: "Initializing..." })
+    ] });
+  }
+  return /* @__PURE__ */ jsx38(BaseSuiteRunDetails, { runId: runSuiteResult.data.id, title, menuState: state });
+};
+
+// src/app/views/suites/SuitesList.tsx
+import { useNavigate as useNavigate12 } from "react-router";
+import { jsx as jsx39 } from "react/jsx-runtime";
+var SuitesList = () => {
+  const navigate = useNavigate12();
+  return /* @__PURE__ */ jsx39(
+    BaseSuitesList,
+    {
+      onSelectSuite: (suite) => navigate(ROUTES.suites.details(suite.id), { state: { suiteName: getSuiteName(suite) } })
+    }
+  );
+};
+
+// src/app/views/suites/SuitesMenu.tsx
+import { jsx as jsx40 } from "react/jsx-runtime";
+var SuitesMenu = () => {
+  return /* @__PURE__ */ jsx40(ViewLayout, { children: /* @__PURE__ */ jsx40(
+    MenuList,
+    {
+      options: [
+        { label: "List suites", shortcut: "l", to: "/suites/list" },
+        { label: "Run a suite", shortcut: "r", to: "/suites/run" }
+      ]
+    }
+  ) });
+};
+
+// src/app/views/testRuns/TestRunDebugArtifacts.tsx
+import { Spinner as Spinner13, StatusMessage as StatusMessage15 } from "@inkjs/ui";
+import { useLocation as useLocation11, useParams as useParams8 } from "react-router";
+
+// src/app/hooks/useTestRuns.ts
+var useTestRunsList = () => useFeatureQuery(() => listTestRuns(), []);
+var useTestRunDetails = (runId) => useFeatureQuery(async () => {
+  if (!runId) return void 0;
+  return getTestRunDetails(runId);
+}, [runId]);
+
+// src/app/views/testRuns/TestRunDebugArtifacts.tsx
+import { jsx as jsx41 } from "react/jsx-runtime";
+var ArtifactsUnavailableMessage = () => /* @__PURE__ */ jsx41(StatusMessage15, { variant: "warning", children: "No debug artifacts available" });
+var DebugArtifacts = ({ runId }) => {
+  const request = useFeatureQuery(() => listTestRunDebugArtifacts(runId), [runId]);
+  if (request.isLoading) {
+    return /* @__PURE__ */ jsx41(Spinner13, { label: `Loading debug artifacts for ${runId}...` });
+  }
+  if (request.isError) {
+    return /* @__PURE__ */ jsx41(StatusMessage15, { variant: "error", children: request.error });
+  }
+  if (!request.data || request.data.length === 0) {
+    return /* @__PURE__ */ jsx41(ArtifactsUnavailableMessage, {});
+  }
+  return /* @__PURE__ */ jsx41(
+    MenuList,
+    {
+      options: request.data.map((artifact) => ({
+        label: getDebugArtifactLabel(artifact),
+        value: artifact
+      })),
+      onSelect: (item) => {
+        const artifact = item.value;
+        if (artifact?.file) {
+          void openExternalUrl(artifact.file);
+        }
+      }
+    }
+  );
+};
+var TestRunDebugArtifacts = () => {
+  const { runId } = useParams8();
+  const location = useLocation11();
+  const state = location.state;
+  const detailsRequest = useTestRunDetails(runId);
+  const title = detailsRequest.data ? getTestRunName(detailsRequest.data) : state?.testRunName ?? "Debug artifacts";
+  return /* @__PURE__ */ jsx41(
+    ViewLayout,
+    {
+      title,
+      hints: runId ? "navigationOpenSelect" : "none",
+      hintsPosition: "bottom",
+      children: runId ? /* @__PURE__ */ jsx41(DebugArtifacts, { runId }) : /* @__PURE__ */ jsx41(ArtifactsUnavailableMessage, {})
+    }
+  );
+};
+
+// src/app/views/testRuns/TestRunDetails.tsx
+import { Spinner as Spinner14, StatusMessage as StatusMessage16 } from "@inkjs/ui";
+import { Text as Text12 } from "ink";
+import { useLocation as useLocation12, useParams as useParams9 } from "react-router";
+import { jsx as jsx42, jsxs as jsxs22 } from "react/jsx-runtime";
+var TestRunDetails = () => {
+  const { runId } = useParams9();
+  const location = useLocation12();
+  const state = location.state;
+  const request = useTestRunDetails(runId);
+  const title = request.data ? getTestRunName(request.data) : state?.testRunName;
+  const menuState = title ? { testRunName: title } : void 0;
+  if (!request.data || !runId) {
+    return /* @__PURE__ */ jsxs22(ViewLayout, { title, hintsHidden: true, children: [
+      request.isLoading && /* @__PURE__ */ jsx42(Spinner14, { label: "Loading test run..." }),
+      request.isError && /* @__PURE__ */ jsx42(StatusMessage16, { variant: "error", children: request.error }),
+      !request.isLoading && !request.isError && !request.data && /* @__PURE__ */ jsx42(Text12, { color: "yellow", children: "Test run not found." })
+    ] });
+  }
+  return /* @__PURE__ */ jsx42(BaseTestRunDetails, { runId, title, menuState });
+};
+
+// src/app/views/testRuns/TestRunJunitReport.tsx
+import { Spinner as Spinner15, StatusMessage as StatusMessage17 } from "@inkjs/ui";
+import { Text as Text13 } from "ink";
+import { useEffect as useEffect13 } from "react";
+import { useLocation as useLocation13, useParams as useParams10 } from "react-router";
+import { Fragment as Fragment3, jsx as jsx43, jsxs as jsxs23 } from "react/jsx-runtime";
+var DownloadReport = ({ runId }) => {
+  const [downloadReport, downloadReportResult] = useFeatureMutation(async (runId2) => {
+    const xml = await getTestRunJunitReport(runId2);
+    return writeReportXml(xml, defaultJunitReportPath("test", runId2));
+  });
+  useEffect13(() => {
+    void downloadReport(runId);
+  }, [downloadReport, runId]);
+  return /* @__PURE__ */ jsxs23(Fragment3, { children: [
+    downloadReportResult.isLoading && /* @__PURE__ */ jsx43(Spinner15, { label: "Downloading JUnit report..." }),
+    downloadReportResult.isError && /* @__PURE__ */ jsx43(StatusMessage17, { variant: "error", children: downloadReportResult.error }),
+    downloadReportResult.data?.outPath && /* @__PURE__ */ jsx43(StatusMessage17, { variant: "success", children: `Saved JUnit report to ${downloadReportResult.data.outPath} (${downloadReportResult.data.size} chars)` })
+  ] });
+};
+var TestRunJunitReport = () => {
+  const { runId } = useParams10();
+  const location = useLocation13();
+  const state = location.state;
+  const request = useTestRunDetails(runId);
+  const title = request.data ? getTestRunName(request.data) : state?.testRunName ?? runId;
+  return /* @__PURE__ */ jsxs23(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+    request.isLoading && /* @__PURE__ */ jsx43(Spinner15, { label: "Loading..." }),
+    request.isError && /* @__PURE__ */ jsx43(Text13, { color: "red", children: request.error }),
+    !request.isLoading && !request.isError && runId && /* @__PURE__ */ jsx43(DownloadReport, { runId }),
+    !request.isLoading && !request.isError && !runId && /* @__PURE__ */ jsx43(StatusMessage17, { variant: "warning", children: "No test run selected" })
+  ] });
+};
+
+// src/app/views/testRuns/TestRunOpen.tsx
+import { Spinner as Spinner16, StatusMessage as StatusMessage18 } from "@inkjs/ui";
+import { Box as Box13, Text as Text14 } from "ink";
+import { useEffect as useEffect14 } from "react";
+import { useLocation as useLocation14, useParams as useParams11 } from "react-router";
+import { Fragment as Fragment4, jsx as jsx44, jsxs as jsxs24 } from "react/jsx-runtime";
+var WebUrlUnavailableMessage3 = () => /* @__PURE__ */ jsx44(StatusMessage18, { variant: "warning", children: "No web URL available for this run" });
+var OpenRun = ({ url }) => {
+  const [openRun, openRunResult] = useFeatureMutation(async (url2) => {
+    await openExternalUrl(url2);
+    return url2;
+  });
+  useEffect14(() => {
+    if (url) void openRun(url);
+  }, [openRun, url]);
+  if (!url) return /* @__PURE__ */ jsx44(WebUrlUnavailableMessage3, {});
+  return /* @__PURE__ */ jsxs24(Fragment4, { children: [
+    openRunResult.isLoading && /* @__PURE__ */ jsx44(Spinner16, { label: "Opening BugBug..." }),
+    openRunResult.isError && /* @__PURE__ */ jsx44(StatusMessage18, { variant: "error", children: openRunResult.error }),
+    openRunResult.data && /* @__PURE__ */ jsxs24(Box13, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx44(StatusMessage18, { variant: "success", children: "Opened in BugBug" }),
+      /* @__PURE__ */ jsx44(Text14, { dimColor: true, children: openRunResult.data })
+    ] })
+  ] });
+};
+var TestRunOpen = () => {
+  const { runId } = useParams11();
+  const location = useLocation14();
+  const state = location.state;
+  const request = useTestRunDetails(runId);
+  const title = request.data ? getTestRunName(request.data) : state?.testRunName ?? runId;
+  return /* @__PURE__ */ jsxs24(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+    request.isLoading && /* @__PURE__ */ jsx44(Spinner16, { label: "Loading..." }),
+    request.isError && /* @__PURE__ */ jsx44(Text14, { color: "red", children: request.error }),
+    !request.isLoading && !request.isError && /* @__PURE__ */ jsx44(OpenRun, { url: request.data?.webappUrl })
+  ] });
+};
+
+// src/app/views/testRuns/TestRunsList.tsx
+import { jsx as jsx45 } from "react/jsx-runtime";
+var TestRunsList2 = () => {
+  const request = useTestRunsList();
+  return /* @__PURE__ */ jsx45(
+    TestRunsList,
+    {
+      testRuns: request.data,
+      isLoading: request.isLoading,
+      isError: request.isError,
+      error: request.error
+    }
+  );
+};
+
+// src/app/views/testRuns/TestRunsMenu.tsx
+import { useEffect as useEffect15 } from "react";
+import { useNavigate as useNavigate13 } from "react-router";
+var TestRunsMenu = () => {
+  const navigate = useNavigate13();
+  useEffect15(() => {
+    navigate(ROUTES.testRuns.list(), { replace: true });
+  }, [navigate]);
+  return null;
+};
+
+// src/app/views/tests/RunTest.tsx
+import { useNavigate as useNavigate14 } from "react-router";
+
+// src/app/views/tests/BaseTestsList.tsx
+import { useState as useState15 } from "react";
+
+// src/app/hooks/useTests.ts
+var useTestsList = (query) => useFeatureQuery(() => loadTestTableResources(query), [query]);
+var useTestDetails = (testId) => useFeatureQuery(async () => {
+  if (!testId) return void 0;
+  return getTestDetails(testId);
+}, [testId]);
+
+// src/features/tests/tests.constants.tsx
+import { jsx as jsx46 } from "react/jsx-runtime";
+var TEST_COLUMNS = [
+  { key: "name", label: "Name", width: 42 },
+  {
+    key: "status",
+    label: "Status",
+    width: 14,
+    render: (_cell, row, ctx) => /* @__PURE__ */ jsx46(Status, { status: row.value?.status, color: ctx.color, backgroundColor: ctx.backgroundColor })
+  }
+];
+
+// src/features/tests/tests.utils.tsx
+var getTestRow = (test) => ({
+  key: test.id,
+  cells: {
+    name: getTestName(test),
+    status: formatRunStatus(test.status)
+  },
+  value: test
+});
+var getTestName = (test) => test.name || test.id || "Untitled";
+
+// src/app/views/tests/BaseTestsList.tsx
+import { jsx as jsx47 } from "react/jsx-runtime";
+var BaseTestsList = ({
+  title,
+  emptyMessage = "No tests found",
+  onSelectTest
+}) => {
+  const [query, setQuery] = useState15("");
+  const request = useTestsList(query);
+  return /* @__PURE__ */ jsx47(
+    BaseResourceListScreen,
+    {
+      title,
+      loadingLabel: "Loading tests...",
+      emptyMessage,
+      resources: request.data,
+      isLoading: request.isLoading,
+      isError: request.isError,
+      error: request.error,
+      columns: TEST_COLUMNS,
+      getRow: getTestRow,
+      searchable: true,
+      query,
+      onSearch: (next) => setQuery(next.trim()),
+      onSelectResource: onSelectTest
+    }
+  );
+};
+
+// src/app/views/tests/RunTest.tsx
+import { jsx as jsx48 } from "react/jsx-runtime";
+var RunTest = () => {
+  const navigate = useNavigate14();
+  return /* @__PURE__ */ jsx48(
+    BaseTestsList,
+    {
+      title: "Select a test to run:",
+      emptyMessage: "No tests available",
+      onSelectTest: (test) => navigate(ROUTES.tests.run(test.id))
+    }
+  );
+};
+
+// src/app/views/tests/TestDetails.tsx
+import { Spinner as Spinner17, StatusMessage as StatusMessage19 } from "@inkjs/ui";
+import { Box as Box14 } from "ink";
+import { useLocation as useLocation15, useParams as useParams12 } from "react-router";
+import { jsx as jsx49, jsxs as jsxs25 } from "react/jsx-runtime";
+var TestDetails = () => {
+  const { testId } = useParams12();
+  const location = useLocation15();
+  const state = location.state;
+  const request = useTestDetails(testId);
+  const title = request.data ? getTestName(request.data) : state?.testName;
+  const detailsState = title ? { testName: title } : void 0;
+  const data = request.data;
+  const isNotFound = !request.isLoading && !request.isError && data === void 0;
+  const isReady = !request.isLoading && !request.isError && data !== void 0;
+  const hints = isReady ? void 0 : "none";
+  const options = [
+    {
+      label: "Run",
+      shortcut: "r",
+      description: "Start a fresh run of this test",
+      to: ROUTES.tests.run(testId ?? ""),
+      state: detailsState
+    },
+    {
+      label: "Show last run",
+      shortcut: "h",
+      description: "View the most recent run for this test",
+      to: ROUTES.tests.lastRun(testId ?? ""),
+      state: detailsState
+    },
+    {
+      label: "Export (YAML)",
+      shortcut: "e",
+      description: "Save the test definition to a YAML file in the current directory",
+      to: ROUTES.tests.export(testId ?? "")
+    },
+    {
+      label: "Open in BugBug",
+      shortcut: "o",
+      description: "Open the test page in your browser",
+      to: ROUTES.tests.open(testId ?? "")
+    }
+  ];
+  return /* @__PURE__ */ jsxs25(ViewLayout, { title, hints, children: [
+    request.isLoading && /* @__PURE__ */ jsx49(Box14, { children: /* @__PURE__ */ jsx49(Spinner17, { label: "Loading test..." }) }),
+    request.isError && /* @__PURE__ */ jsx49(StatusMessage19, { variant: "error", children: request.error }),
+    isNotFound && /* @__PURE__ */ jsx49(StatusMessage19, { variant: "warning", children: "Test not found." }),
+    isReady && /* @__PURE__ */ jsx49(MenuList, { options })
+  ] });
+};
+
+// src/app/views/tests/TestDetailsExport.tsx
+import { StatusMessage as StatusMessage20 } from "@inkjs/ui";
+import { Spinner as Spinner18 } from "@inkjs/ui";
+import { useEffect as useEffect16 } from "react";
+import { useParams as useParams13 } from "react-router";
+import { jsx as jsx50, jsxs as jsxs26 } from "react/jsx-runtime";
+var TestDetailsExport = () => {
+  const { testId } = useParams13();
+  const [exportTestMutation, exportTestResult] = useFeatureMutation(
+    (id) => exportTest(id, "yaml")
+  );
+  useEffect16(() => {
+    if (testId) void exportTestMutation(testId);
+  }, [exportTestMutation, testId]);
+  return /* @__PURE__ */ jsxs26(ViewLayout, { hintsHidden: true, children: [
+    exportTestResult.isLoading && /* @__PURE__ */ jsx50(Spinner18, { label: `Exporting ${testId}...` }),
+    exportTestResult.isError && /* @__PURE__ */ jsx50(StatusMessage20, { variant: "error", children: exportTestResult.error }),
+    exportTestResult.data && /* @__PURE__ */ jsx50(StatusMessage20, { variant: "success", children: `Exported to ${exportTestResult.data.outPath} (${exportTestResult.data.size} chars)` })
+  ] });
+};
+
+// src/app/views/tests/TestDetailsLastRun.tsx
+import { Spinner as Spinner19, StatusMessage as StatusMessage21 } from "@inkjs/ui";
+import { Text as Text15 } from "ink";
+import { useLocation as useLocation16, useParams as useParams14 } from "react-router";
+import { jsx as jsx51, jsxs as jsxs27 } from "react/jsx-runtime";
+var TestDetailsLastRun = () => {
+  const { testId } = useParams14();
+  const location = useLocation16();
+  const state = location.state;
+  const request = useTestDetails(testId);
+  const test = request.data;
+  const isReady = !request.isLoading && !request.isError;
+  const title = test ? getTestName(test) : state?.testName ?? testId;
+  if (!isReady || !test?.lastRunId) {
+    return /* @__PURE__ */ jsxs27(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+      request.isLoading && /* @__PURE__ */ jsx51(Spinner19, { label: "Loading..." }),
+      request.isError && /* @__PURE__ */ jsx51(Text15, { color: "red", children: request.error }),
+      isReady && !test?.lastRunId && /* @__PURE__ */ jsx51(StatusMessage21, { variant: "warning", children: `No previous run found for ${test ? getTestName(test) : testId ?? "test"}` })
+    ] });
+  }
+  return /* @__PURE__ */ jsx51(BaseTestRunDetails, { runId: test.lastRunId, title, menuState: { testRunName: title } });
+};
+
+// src/app/views/tests/TestDetailsOpen.tsx
+import { StatusMessage as StatusMessage22 } from "@inkjs/ui";
+import { Spinner as Spinner20 } from "@inkjs/ui";
+import { Box as Box15, Text as Text16 } from "ink";
+import { useEffect as useEffect17 } from "react";
+import { useParams as useParams15 } from "react-router";
+import { jsx as jsx52, jsxs as jsxs28 } from "react/jsx-runtime";
+var WebUrlUnavailableMessage4 = () => /* @__PURE__ */ jsx52(StatusMessage22, { variant: "warning", children: "No web URL available for this test" });
+var TestDetailsOpen = () => {
+  const { testId } = useParams15();
+  const request = useFeatureQuery(async () => {
+    if (!testId) return void 0;
+    return getTest(testId);
+  }, [testId]);
+  const url = request.data?.webappUrl;
+  const isReady = !request.isLoading && !request.isError;
+  const [openTest, openTestResult] = useFeatureMutation(async (url2) => {
+    await openExternalUrl(url2);
+    return url2;
+  });
+  useEffect17(() => {
+    if (isReady && url) void openTest(url);
+  }, [isReady, openTest, url]);
+  return /* @__PURE__ */ jsxs28(ViewLayout, { hintsHidden: true, children: [
+    request.isLoading && /* @__PURE__ */ jsx52(Spinner20, { label: "Loading..." }),
+    request.isError && /* @__PURE__ */ jsx52(Text16, { color: "red", children: request.error }),
+    isReady && !url && /* @__PURE__ */ jsx52(WebUrlUnavailableMessage4, {}),
+    isReady && url && openTestResult.isLoading && /* @__PURE__ */ jsx52(Spinner20, { label: "Opening BugBug..." }),
+    isReady && url && openTestResult.isError && /* @__PURE__ */ jsx52(StatusMessage22, { variant: "error", children: openTestResult.error }),
+    isReady && url && openTestResult.data && /* @__PURE__ */ jsxs28(Box15, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx52(StatusMessage22, { variant: "success", children: "Opened in BugBug" }),
+      /* @__PURE__ */ jsx52(Text16, { dimColor: true, children: openTestResult.data })
+    ] })
+  ] });
+};
+
+// src/app/views/tests/TestDetailsRun.tsx
+import { Spinner as Spinner21, StatusMessage as StatusMessage23 } from "@inkjs/ui";
+import { useEffect as useEffect18 } from "react";
+import { useLocation as useLocation17, useNavigate as useNavigate15, useParams as useParams16 } from "react-router";
+import { jsx as jsx53, jsxs as jsxs29 } from "react/jsx-runtime";
+var TestDetailsRun = () => {
+  const { testId } = useParams16();
+  const location = useLocation17();
+  const navigate = useNavigate15();
+  const state = location.state;
+  const title = state?.testName ?? testId;
+  const [runTestMutation, runTestResult] = useFeatureMutation((id) => runTest(id, {}));
+  useEffect18(() => {
+    if (!testId) return;
+    const startRun = async () => {
+      try {
+        const result = await runTestMutation(testId);
+        if ("data" in result) {
+          navigate(ROUTES.tests.lastRun(testId), { replace: true, state });
+        }
+      } catch {
+      }
+    };
+    startRun();
+  }, [navigate, runTestMutation, state, testId]);
+  if (!runTestResult.data) {
+    return /* @__PURE__ */ jsxs29(ViewLayout, { title, hintsHidden: true, hintsPosition: "bottom", children: [
+      runTestResult.isError && /* @__PURE__ */ jsx53(StatusMessage23, { variant: "error", children: runTestResult.error }),
+      !runTestResult.isError && /* @__PURE__ */ jsx53(Spinner21, { label: "Initializing..." })
+    ] });
+  }
+  return /* @__PURE__ */ jsx53(BaseTestRunDetails, { runId: runTestResult.data.id, title, menuState: state });
+};
+
+// src/app/views/tests/TestImport.tsx
+import { Spinner as Spinner22, StatusMessage as StatusMessage24 } from "@inkjs/ui";
+import { useEffect as useEffect19, useState as useState16 } from "react";
+import { useNavigate as useNavigate16 } from "react-router";
+import { jsx as jsx54, jsxs as jsxs30 } from "react/jsx-runtime";
+var TestImport = ({ initialDirectory } = {}) => {
+  const navigate = useNavigate16();
+  const [file, setFile] = useState16(null);
+  const [conflictMode, setConflictMode] = useState16(null);
+  const [importTestMutation, importTestResult] = useFeatureMutation(
+    async ({ file: file2, conflictMode: conflictMode2 }) => {
+      detectFormat(file2);
+      return importTest(file2, {
+        conflictMode: conflictMode2 || void 0
+      });
+    }
+  );
+  useEffect19(() => {
+    if (file && conflictMode !== null) {
+      void importTestMutation({ file, conflictMode });
+    }
+  }, [conflictMode, file, importTestMutation]);
+  useEscHandler(() => {
+    if (!file || conflictMode !== null) return false;
+    setFile(null);
+    return true;
+  });
+  if (!file) {
+    return /* @__PURE__ */ jsx54(
+      FilePicker,
+      {
+        label: "Select .yaml/.yml/.zip file",
+        initialDir: initialDirectory,
+        extensions: [".yaml", ".yml", ".zip"],
+        onSubmit: setFile,
+        onBack: () => navigate(-1)
+      }
+    );
+  }
+  if (conflictMode === null) {
+    return /* @__PURE__ */ jsx54(ViewLayout, { title: "Conflict mode (blank = API default)", children: /* @__PURE__ */ jsx54(
+      MenuList,
+      {
+        options: [
+          { label: "Default", value: "" },
+          { label: "Overwrite", value: "overwrite" }
+        ],
+        onSelect: (item) => setConflictMode(item.value ?? "")
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxs30(ViewLayout, { hintsHidden: true, hintsPosition: "bottom", children: [
+    importTestResult.isLoading && /* @__PURE__ */ jsx54(Spinner22, { label: `Importing ${file}...` }),
+    importTestResult.isError && /* @__PURE__ */ jsx54(StatusMessage24, { variant: "error", children: importTestResult.error }),
+    importTestResult.data && /* @__PURE__ */ jsx54(StatusMessage24, { variant: "success", children: `Imported test: ${importTestResult.data.id ?? "(unknown)"}${importTestResult.data.name ? ` (${importTestResult.data.name})` : ""}` })
+  ] });
+};
+
+// src/app/views/tests/TestsList.tsx
+import { useNavigate as useNavigate17 } from "react-router";
+import { jsx as jsx55 } from "react/jsx-runtime";
+var TestsList = () => {
+  const navigate = useNavigate17();
+  return /* @__PURE__ */ jsx55(
+    BaseTestsList,
+    {
+      onSelectTest: (test) => navigate(ROUTES.tests.details(test.id), { state: { testName: getTestName(test) } })
+    }
+  );
+};
+
+// src/app/views/tests/TestsMenu.tsx
+import { jsx as jsx56 } from "react/jsx-runtime";
+var TestsMenu = () => {
+  return /* @__PURE__ */ jsx56(ViewLayout, { children: /* @__PURE__ */ jsx56(
+    MenuList,
+    {
+      options: [
+        { label: "List tests", shortcut: "l", to: "/tests/list" },
+        {
+          label: "Import test",
+          shortcut: "i",
+          description: "YAML or ZIP",
+          to: "/tests/import"
+        },
+        { label: "Run a test", shortcut: "r", to: "/tests/run" }
+      ]
+    }
+  ) });
+};
+
+// src/app/router.tsx
+import { jsx as jsx57, jsxs as jsxs31 } from "react/jsx-runtime";
+var createNavigatorRouter = ({
+  initialRoute,
+  initialRouteState
+} = {}) => {
+  const getInitialEntries = () => {
+    if (initialRoute) {
+      const routeEntry = initialRouteState === void 0 ? initialRoute : { pathname: initialRoute, state: initialRouteState };
+      return [ROUTES.root(), routeEntry];
+    }
+    return [ROUTES.root()];
+  };
+  const initialEntries = getInitialEntries();
+  const router = createMemoryRouter(
+    createRoutesFromElements(
+      /* @__PURE__ */ jsxs31(Route, { element: /* @__PURE__ */ jsx57(Navigator, {}), children: [
+        /* @__PURE__ */ jsx57(Route, { index: true, element: /* @__PURE__ */ jsx57(MainMenu, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/init", element: /* @__PURE__ */ jsx57(ProjectInit, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests", element: /* @__PURE__ */ jsx57(TestsMenu, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests/list", element: /* @__PURE__ */ jsx57(TestsList, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests/import", element: /* @__PURE__ */ jsx57(TestImport, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests/run", element: /* @__PURE__ */ jsx57(RunTest, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests/:testId", element: /* @__PURE__ */ jsx57(TestDetails, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests/:testId/run", element: /* @__PURE__ */ jsx57(TestDetailsRun, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests/:testId/lastRun", element: /* @__PURE__ */ jsx57(TestDetailsLastRun, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests/:testId/export", element: /* @__PURE__ */ jsx57(TestDetailsExport, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/tests/:testId/open", element: /* @__PURE__ */ jsx57(TestDetailsOpen, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/testruns", element: /* @__PURE__ */ jsx57(TestRunsMenu, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/testruns/list", element: /* @__PURE__ */ jsx57(TestRunsList2, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/testruns/:runId", element: /* @__PURE__ */ jsx57(TestRunDetails, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/testruns/:runId/debugArtifacts", element: /* @__PURE__ */ jsx57(TestRunDebugArtifacts, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/testruns/:runId/junitReport", element: /* @__PURE__ */ jsx57(TestRunJunitReport, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/testruns/:runId/open", element: /* @__PURE__ */ jsx57(TestRunOpen, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suites", element: /* @__PURE__ */ jsx57(SuitesMenu, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suites/list", element: /* @__PURE__ */ jsx57(SuitesList, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suites/run", element: /* @__PURE__ */ jsx57(RunSuite, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suites/:suiteId", element: /* @__PURE__ */ jsx57(SuiteDetails, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suites/:suiteId/run", element: /* @__PURE__ */ jsx57(SuiteDetailsRun, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suites/:suiteId/lastRun", element: /* @__PURE__ */ jsx57(SuiteDetailsLastRun, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suites/:suiteId/open", element: /* @__PURE__ */ jsx57(SuiteDetailsOpen, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suiteruns", element: /* @__PURE__ */ jsx57(SuiteRunsMenu, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suiteruns/list", element: /* @__PURE__ */ jsx57(SuiteRunsList, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suiteruns/:runId", element: /* @__PURE__ */ jsx57(SuiteRunDetails, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suiteruns/:runId/showTestRuns", element: /* @__PURE__ */ jsx57(SuiteRunShowTestRuns, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/suiteruns/:runId/open", element: /* @__PURE__ */ jsx57(SuiteRunOpen, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/profiles", element: /* @__PURE__ */ jsx57(ProfilesMenu, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/profiles/list", element: /* @__PURE__ */ jsx57(ProfilesList, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/project", element: /* @__PURE__ */ jsx57(ProjectMenu, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/project/switch", element: /* @__PURE__ */ jsx57(ProjectSwitch, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/project/export", element: /* @__PURE__ */ jsx57(ProjectExport, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/project/import", element: /* @__PURE__ */ jsx57(ProjectImport, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/settings", element: /* @__PURE__ */ jsx57(SettingsMenu, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/settings/setSessionToken", element: /* @__PURE__ */ jsx57(SettingsSetSessionToken, {}) }),
+        /* @__PURE__ */ jsx57(Route, { path: "/logout", element: /* @__PURE__ */ jsx57(Logout, {}) })
+      ] })
+    ),
+    { initialEntries, initialIndex: initialEntries.length - 1 }
+  );
+  let currentPathname = router.state.location.pathname;
+  router.subscribe((state) => {
+    const nextPathname = state.location.pathname;
+    if (nextPathname === currentPathname) return;
+    currentPathname = nextPathname;
+    analytics.trackTuiNavigation(nextPathname);
+  });
+  return router;
+};
+
+// src/app/NavigatorApp.tsx
+import { jsx as jsx58 } from "react/jsx-runtime";
+var NavigatorApp = ({ initialRoute, initialRouteState }) => {
+  const [router] = useState17(() => createNavigatorRouter({ initialRoute, initialRouteState }));
+  return /* @__PURE__ */ jsx58(NavigatorSessionProvider, { children: /* @__PURE__ */ jsx58(RouterProvider, { router }) });
+};
+export {
+  NavigatorApp
+};
+//# sourceMappingURL=NavigatorApp-WSJMM3OT.js.map