@kal-elsam/kairo-runtime 0.2.3 → 0.3.1

package/README.md

@@ -33,10 +33,24 @@ kairo
 ```
 
 **First run** (no `~/.harness/state.json`): interactive onboarding → safe diagnosis →
-setup with confirmation → operations dashboard.
+setup with confirmation → full-screen operations cockpit.
 
-**Later runs** (state present): operations dashboard with a stable purpose line and a
-contextual next step (configure, enable intelligence, launch a run, or review problems).
+**Later runs** (state present): full-screen cockpit with mission control (recommended
+action), navigation, and a system strip. Layout adapts to terminal size:
+
+| Mode | Size | Layout |
+|------|------|--------|
+| Wide | ≥100 cols × ≥28 rows | Nav + content + system |
+| Compact | ≥72×20 | Nav + content |
+| Minimal | 60–71 cols or short height | Single panel + nav header |
+| Below gate | <60 cols | Explicit TTY fallback (Ink disabled) |
+
+Keys: `↑↓` navigate · `Enter` open · `Esc` back (exit only from Overview) ·
+`R` refresh · `C` cancel run · `?` help. `Tab` switches region only when content
+is interactive (run lists / launch).
+
+Respects `NO_COLOR`, `HARNESS_ASCII=1`, and `HARNESS_INK=0`. Status is always labeled
+in text, never color alone.
 
 Explicit commands and setup flags keep their current behavior (`kairo setup`,
 `kairo --dry-run`, `kairo shell`, non-TTY scripts, etc.).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kal-elsam/kairo-runtime",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Kairo Runtime — local agent operating system for Codex, Cursor, Claude, Gemini, Copilot, Engram, and Graphify.",
   "type": "module",
   "homepage": "https://github.com/Kal-elSam/harness#readme",
@@ -33,6 +33,7 @@
     "doctor": "node ./bin/kairo.js doctor",
     "smoke": "bash scripts/smoke-test.sh",
     "ux:smoke": "bash scripts/ux-smoke-test.sh",
+    "smoke:cockpit": "bash scripts/cockpit-smoke-test.sh",
     "smoke:registry": "bash scripts/registry-smoke-test.sh",
     "smoke:installer": "bash scripts/installer-smoke-test.sh",
     "smoke:bridge": "bash scripts/bridge-smoke-test.sh",
@@ -59,6 +60,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
+    "ansi-escapes": "^7.3.0",
     "ink": "^5.2.1",
     "react": "^18.3.1"
   }

package/scripts/check-published-release.mjs

@@ -113,8 +113,11 @@ export async function verifyPublishedRelease({
   }
 
   const remoteTagLine = runGit(`git ls-remote --tags origin refs/tags/${releaseTag}`).trim();
+  const remotePeeledLine = runGit(`git ls-remote origin refs/tags/${releaseTag}^{}`).trim();
+  const remotePointsAtGitHead = remoteTagLine.startsWith(gitHead)
+    || remotePeeledLine.startsWith(gitHead);
 
-  if (!remoteTagLine.startsWith(gitHead)) {
+  if (!remotePointsAtGitHead) {
     throw new Error(
       `Remote tag ${releaseTag} on origin does not point to npm gitHead (${gitHead})`
     );

package/scripts/cockpit-smoke-test.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Cockpit smoke — layout/capabilities + package wiring (no PTY required).
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+
+echo "Kairo cockpit smoke"
+node "$ROOT/scripts/cockpit-smoke.mjs"
+
+node --test \
+  test/fullscreen-session.test.js \
+  test/layout.test.js \
+  test/terminal-capabilities.test.js \
+  test/cockpit-models.test.js \
+  test/cockpit-controller.test.js \
+  test/cockpit-frame.test.js \
+  test/cockpit-navigation.test.js \
+  test/cockpit-input-integration.test.js
+
+echo "Kairo cockpit smoke passed"

package/scripts/cockpit-smoke.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveLayoutMode, LAYOUT_MODES } from "../src/global/ink/layout.js";
+import { resolveTerminalCapabilities } from "../src/global/ink/terminal-capabilities.js";
+import { createFullscreenSession } from "../src/global/ink/fullscreen-session.js";
+import {
+  buildFooterModel,
+  buildHomeMissionModel,
+  buildTopBarModel,
+  COCKPIT_NAV,
+  COCKPIT_REGIONS
+} from "../src/global/ink/cockpit-models.js";
+import {
+  createCockpitUiState,
+  reduceCockpitUi,
+  routeCockpitKey
+} from "../src/global/ink/cockpit-controller.js";
+import { ORCHESTRATOR_VIEWS } from "../src/global/ink/orchestrator-state.js";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const require = createRequire(import.meta.url);
+const pkg = require(join(root, "package.json"));
+
+assert.equal(pkg.version, "0.3.1");
+assert.ok(pkg.dependencies["ansi-escapes"]);
+
+assert.equal(resolveLayoutMode({ columns: 120, rows: 40 }), LAYOUT_MODES.WIDE);
+assert.equal(resolveLayoutMode({ columns: 80, rows: 24 }), LAYOUT_MODES.COMPACT);
+assert.equal(resolveLayoutMode({ columns: 65, rows: 24 }), LAYOUT_MODES.MINIMAL);
+assert.equal(resolveLayoutMode({ columns: 50, rows: 24 }), null);
+
+const caps = resolveTerminalCapabilities({
+  columns: 80,
+  rows: 24,
+  isTTY: true,
+  term: "xterm-256color",
+  env: { NO_COLOR: "1" }
+});
+assert.equal(caps.color, false);
+assert.equal(caps.canUseInk, true);
+
+const session = createFullscreenSession({
+  stdout: { isTTY: true, write: () => true },
+  processRef: { on() {}, removeListener() {}, exit() {} },
+  onSignal: () => {}
+});
+assert.equal(session.enter(), true);
+assert.equal(session.leave(), true);
+assert.equal(session.leave(), false);
+
+const top = buildTopBarModel({ projectName: "smoke" });
+assert.match(top.status, /ONLINE|Offline/);
+const mission = buildHomeMissionModel({
+  hasGlobalState: false,
+  diagnostics: { diagnostics: { detected: 0 } },
+  dashboard: { providers: [], recentRuns: [] }
+});
+assert.match(mission.title, /MISSION CONTROL/);
+
+function applyKey(state, keyAction) {
+  const routed = routeCockpitKey(state, keyAction);
+  if (!routed) return state;
+  return reduceCockpitUi(state, routed);
+}
+
+function smokeNavigation(layoutMode) {
+  let state = createCockpitUiState({
+    layoutMode,
+    region: layoutMode === LAYOUT_MODES.MINIMAL ? COCKPIT_REGIONS.CONTENT : COCKPIT_REGIONS.NAV
+  });
+  const diagnosticsIndex = COCKPIT_NAV.findIndex((item) => item.id === "diagnostics");
+  while (state.navIndex < diagnosticsIndex) {
+    state = applyKey(state, { type: "arrow", direction: "down" });
+  }
+  state = applyKey(state, { type: "enter" });
+  assert.equal(state.view, ORCHESTRATOR_VIEWS.DIAGNOSTICS);
+  assert.equal(state.region, COCKPIT_REGIONS.NAV);
+
+  state = applyKey(state, { type: "arrow", direction: "up" });
+  state = applyKey(state, { type: "enter" });
+  assert.equal(state.view, ORCHESTRATOR_VIEWS.LAUNCH);
+  assert.equal(state.region, COCKPIT_REGIONS.CONTENT);
+
+  const footer = buildFooterModel({
+    view: ORCHESTRATOR_VIEWS.DIAGNOSTICS,
+    region: COCKPIT_REGIONS.NAV,
+    unicode: false
+  });
+  assert.doesNotMatch(footer.text, /Tab/);
+
+  state = applyKey(state, { type: "escape" });
+  assert.equal(state.view, ORCHESTRATOR_VIEWS.HOME);
+  state = applyKey(state, { type: "escape" });
+  assert.equal(state.shouldExit, true);
+}
+
+smokeNavigation(LAYOUT_MODES.WIDE);
+smokeNavigation(LAYOUT_MODES.COMPACT);
+
+console.log("cockpit smoke OK");

package/src/cli.js

@@ -696,11 +696,11 @@ sections, components, backups, and drift repair under ~/.harness.
 Bootstrap: see README.md (curl install.sh or npx ${PACKAGE_NAME}).
 
 Usage:
-  ${cli}                              First run: onboarding → setup → dashboard (TTY).
-                                      Later: operations dashboard with next-step guidance.
+  ${cli}                              First run: onboarding → setup → cockpit (TTY).
+                                      Later: full-screen cockpit (wide/compact/minimal).
   ${cli} --dry-run                      Setup dry-run (scriptable)
   ${cli} --version
-  ${cli} shell                          Operations dashboard (TTY)
+  ${cli} shell                          Operations cockpit (TTY)
   ${cli} run --agent <id> --task "..." [--model <name>] [--cwd <dir>] [--permissions force] [--capture-transcript] [--follow] [--no-wait] [--json]
   ${cli} runs list [--json] [--limit <n>] [--active-only]
   ${cli} runs show <runId> [--json] [--limit <n>] [--follow]
@@ -741,8 +741,10 @@ Scopes:
                           Explicit --scope=workspace only.
 
 Commands:
-  shell      Operations dashboard (TTY). Bare ${cli} opens onboarding when ~/.harness/state.json
-             is missing, otherwise the dashboard. Explicit ${cli} shell always opens the dashboard.
+  shell      Operations cockpit (TTY). Bare ${cli} opens onboarding when ~/.harness/state.json
+             is missing, otherwise the cockpit. Explicit ${cli} shell always opens the cockpit.
+             Keys: ↑↓ · Enter · Esc back/exit · R refresh · C cancel · ? help.
+             Tab switches region only when content is interactive (runs/launch).
   run        Launch a managed agent run with local audit trail.
   runs       List, inspect, or cancel agent runs under ~/.harness/runs/.
   orchestrator  Read-only capability registry diagnostics (--json supported).

package/src/global/ink/cockpit/primitives.js

@@ -0,0 +1,131 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { COCKPIT_COLORS, statusColor } from "../theme.js";
+
+export function CockpitBadge({ label, kind = "ready", colorEnabled = true }) {
+  return React.createElement(Text, {
+    color: statusColor(kind, { colorEnabled })
+  }, label);
+}
+
+export function CockpitEmptyState({ title, message, hint }) {
+  return React.createElement(Box, { flexDirection: "column", marginY: 1 },
+    title && React.createElement(Text, { bold: true, color: COCKPIT_COLORS.secondary }, title),
+    message && React.createElement(Text, null, message),
+    hint && React.createElement(Text, { color: COCKPIT_COLORS.muted }, hint)
+  );
+}
+
+export function CockpitPanel({ title, focused = false, width, children }) {
+  return React.createElement(Box, {
+    flexDirection: "column",
+    width,
+    borderStyle: "single",
+    borderColor: focused ? COCKPIT_COLORS.primary : COCKPIT_COLORS.muted,
+    paddingX: 1,
+    flexGrow: 1
+  },
+    title && React.createElement(Text, {
+      bold: true,
+      color: focused ? COCKPIT_COLORS.primary : COCKPIT_COLORS.secondary
+    }, title),
+    children
+  );
+}
+
+export function CockpitTopBar({ model, colorEnabled = true }) {
+  return React.createElement(Box, { justifyContent: "space-between", width: "100%" },
+    React.createElement(Text, {
+      bold: true,
+      color: colorEnabled ? COCKPIT_COLORS.primary : undefined
+    }, `╭─ ${model.brand} ─ ${model.status}`),
+    React.createElement(Text, {
+      color: colorEnabled ? COCKPIT_COLORS.muted : undefined
+    }, `${model.projectLabel} ─╮`)
+  );
+}
+
+export function CockpitNav({ model, colorEnabled = true }) {
+  return React.createElement(Box, { flexDirection: "column" },
+    model.items.map((item) =>
+      React.createElement(Text, {
+        key: item.id,
+        bold: item.focused || item.selected,
+        color: item.focused
+          ? (colorEnabled ? COCKPIT_COLORS.primary : undefined)
+          : item.selected
+            ? (colorEnabled ? COCKPIT_COLORS.secondary : undefined)
+            : undefined
+      }, `${item.marker} ${item.label}`)
+    )
+  );
+}
+
+export function CockpitSystemStrip({ model, colorEnabled = true }) {
+  return React.createElement(Box, { flexDirection: "column" },
+    model.rows.map((row) =>
+      React.createElement(Text, { key: row.key },
+        React.createElement(Text, { color: COCKPIT_COLORS.muted }, `${row.key.padEnd(7)}`),
+        React.createElement(CockpitBadge, {
+          label: row.value,
+          kind: row.kind,
+          colorEnabled
+        })
+      )
+    )
+  );
+}
+
+export function CockpitFooter({ model }) {
+  return React.createElement(Box, { flexDirection: "column" },
+    React.createElement(Text, { color: COCKPIT_COLORS.muted },
+      `├${"─".repeat(62)}┤`
+    ),
+    React.createElement(Text, { color: COCKPIT_COLORS.muted }, `│ ${model.text}`),
+    React.createElement(Text, { color: COCKPIT_COLORS.muted },
+      `╰${"─".repeat(62)}╯`
+    )
+  );
+}
+
+export function CockpitShell({
+  topBar,
+  footer,
+  layoutMode,
+  nav,
+  system,
+  navFocused,
+  contentFocused,
+  systemFocused,
+  colorEnabled = true,
+  children
+}) {
+  const showNav = layoutMode === "wide" || layoutMode === "compact";
+  const showSystem = layoutMode === "wide";
+
+  return React.createElement(Box, { flexDirection: "column", width: "100%" },
+    React.createElement(CockpitTopBar, { model: topBar, colorEnabled }),
+    layoutMode === "minimal" && nav && React.createElement(Box, { marginY: 0 },
+      React.createElement(Text, { color: COCKPIT_COLORS.muted }, "Nav: "),
+      React.createElement(CockpitNav, { model: nav, colorEnabled })
+    ),
+    React.createElement(Box, { flexDirection: "row", width: "100%" },
+      showNav && React.createElement(CockpitPanel, {
+        title: nav?.title ?? "NAVIGATION",
+        focused: navFocused,
+        width: 22
+      }, React.createElement(CockpitNav, { model: nav, colorEnabled })),
+      React.createElement(CockpitPanel, {
+        title: undefined,
+        focused: contentFocused,
+        width: showSystem ? 48 : showNav ? 56 : "100%"
+      }, children),
+      showSystem && React.createElement(CockpitPanel, {
+        title: system?.title ?? "SYSTEM",
+        focused: systemFocused,
+        width: 20
+      }, React.createElement(CockpitSystemStrip, { model: system, colorEnabled }))
+    ),
+    React.createElement(CockpitFooter, { model: footer })
+  );
+}

package/src/global/ink/cockpit-controller.js

@@ -0,0 +1,168 @@
+import {
+  COCKPIT_NAV,
+  COCKPIT_REGIONS,
+  LAYOUT_MODES,
+  ORCHESTRATOR_VIEWS,
+  canTabBetweenRegions,
+  clamp,
+  defaultRegionForView,
+  interactiveRegionsFor,
+  isContentInteractiveView,
+  isNavFocusedView,
+  regionsForLayout,
+  routeCockpitKey
+} from "./cockpit-focus.js";
+
+export {
+  canTabBetweenRegions,
+  defaultRegionForView,
+  isContentInteractiveView,
+  isNavFocusedView,
+  routeCockpitKey
+};
+
+/**
+ * Pure cockpit focus / navigation reducer — no I/O, no React.
+ */
+export function createCockpitUiState({
+  layoutMode = LAYOUT_MODES.COMPACT,
+  view = ORCHESTRATOR_VIEWS.HOME,
+  region = COCKPIT_REGIONS.NAV,
+  navIndex = 0,
+  listIndex = 0,
+  helpOpen = false,
+  returnView = null
+} = {}) {
+  const regions = regionsForLayout(layoutMode);
+  const preferred = region ?? defaultRegionForView(view, layoutMode);
+  const safeRegion = regions.includes(preferred)
+    ? preferred
+    : defaultRegionForView(view, layoutMode);
+  return {
+    layoutMode,
+    view,
+    region: safeRegion,
+    navIndex: clamp(navIndex, 0, COCKPIT_NAV.length - 1),
+    listIndex: Math.max(0, listIndex),
+    helpOpen,
+    returnView,
+    shouldExit: false
+  };
+}
+
+export function reduceCockpitUi(state, action) {
+  switch (action.type) {
+    case "resize": {
+      const regions = regionsForLayout(action.layoutMode);
+      const preferred = regions.includes(state.region)
+        ? state.region
+        : defaultRegionForView(state.view, action.layoutMode);
+      return { ...state, layoutMode: action.layoutMode, region: preferred };
+    }
+    case "tab": {
+      if (!canTabBetweenRegions(state)) return state;
+      const regions = interactiveRegionsFor(state);
+      const index = regions.indexOf(state.region);
+      const next = regions[(Math.max(index, 0) + 1) % regions.length];
+      return { ...state, region: next };
+    }
+    case "arrow": {
+      if (state.region === COCKPIT_REGIONS.SYSTEM) return state;
+
+      const navigatesNav = state.region === COCKPIT_REGIONS.NAV
+        || isNavFocusedView(state.view)
+        || (state.view === ORCHESTRATOR_VIEWS.HOME
+          && state.layoutMode === LAYOUT_MODES.MINIMAL);
+
+      if (navigatesNav) {
+        const delta = action.direction === "up" ? -1 : 1;
+        return {
+          ...state,
+          navIndex: clamp(state.navIndex + delta, 0, COCKPIT_NAV.length - 1)
+        };
+      }
+
+      if (!isContentInteractiveView(state.view) || state.view === ORCHESTRATOR_VIEWS.LAUNCH) {
+        return state;
+      }
+
+      const delta = action.direction === "up" ? -1 : 1;
+      const max = Math.max(0, (action.listLength ?? 1) - 1);
+      return { ...state, listIndex: clamp(state.listIndex + delta, 0, max) };
+    }
+    case "enter-nav": {
+      const item = COCKPIT_NAV[state.navIndex];
+      if (!item) return state;
+      return {
+        ...state,
+        view: item.view,
+        listIndex: 0,
+        region: defaultRegionForView(item.view, state.layoutMode),
+        helpOpen: false,
+        returnView: null
+      };
+    }
+    case "set-view": {
+      const nextView = action.view;
+      return {
+        ...state,
+        view: nextView,
+        listIndex: 0,
+        region: action.region ?? defaultRegionForView(nextView, state.layoutMode),
+        returnView: action.returnView ?? state.returnView,
+        helpOpen: nextView === ORCHESTRATOR_VIEWS.HELP
+      };
+    }
+    case "toggle-help":
+      if (state.helpOpen || state.view === ORCHESTRATOR_VIEWS.HELP) {
+        return goOverview(state);
+      }
+      return {
+        ...state,
+        helpOpen: true,
+        view: ORCHESTRATOR_VIEWS.HELP,
+        region: defaultRegionForView(ORCHESTRATOR_VIEWS.HELP, state.layoutMode)
+      };
+    case "escape": {
+      if (state.helpOpen || state.view === ORCHESTRATOR_VIEWS.HELP) {
+        return goOverview(state);
+      }
+      if (state.view === ORCHESTRATOR_VIEWS.RUN_DETAIL) {
+        const back = state.returnView && isContentInteractiveView(state.returnView)
+          ? state.returnView
+          : ORCHESTRATOR_VIEWS.ACTIVE_RUNS;
+        return {
+          ...state,
+          view: back,
+          listIndex: 0,
+          region: defaultRegionForView(back, state.layoutMode),
+          returnView: null
+        };
+      }
+      if (state.view !== ORCHESTRATOR_VIEWS.HOME) {
+        return goOverview(state);
+      }
+      return { ...state, shouldExit: true };
+    }
+    case "clear-exit":
+      return { ...state, shouldExit: false };
+    default:
+      return state;
+  }
+}
+
+export function resolveNavAction(navIndex) {
+  return COCKPIT_NAV[navIndex] ?? null;
+}
+
+function goOverview(state) {
+  return {
+    ...state,
+    helpOpen: false,
+    view: ORCHESTRATOR_VIEWS.HOME,
+    navIndex: 0,
+    listIndex: 0,
+    region: defaultRegionForView(ORCHESTRATOR_VIEWS.HOME, state.layoutMode),
+    returnView: null
+  };
+}

package/src/global/ink/cockpit-focus.js

@@ -0,0 +1,92 @@
+import { COCKPIT_NAV, COCKPIT_REGIONS, regionsForLayout } from "./cockpit-models.js";
+import { ORCHESTRATOR_VIEWS } from "./orchestrator-state.js";
+import { LAYOUT_MODES } from "./layout.js";
+
+const NAV_FOCUSED_VIEWS = new Set([
+  ORCHESTRATOR_VIEWS.HOME,
+  ORCHESTRATOR_VIEWS.PROVIDERS,
+  ORCHESTRATOR_VIEWS.DIAGNOSTICS,
+  ORCHESTRATOR_VIEWS.HELP
+]);
+
+const CONTENT_INTERACTIVE_VIEWS = new Set([
+  ORCHESTRATOR_VIEWS.ACTIVE_RUNS,
+  ORCHESTRATOR_VIEWS.RECENT_RUNS,
+  ORCHESTRATOR_VIEWS.RUN_DETAIL,
+  ORCHESTRATOR_VIEWS.LAUNCH
+]);
+
+export function isNavFocusedView(view) {
+  return NAV_FOCUSED_VIEWS.has(view);
+}
+
+export function isContentInteractiveView(view) {
+  return CONTENT_INTERACTIVE_VIEWS.has(view);
+}
+
+export function defaultRegionForView(view, layoutMode = LAYOUT_MODES.COMPACT) {
+  const regions = regionsForLayout(layoutMode);
+  if (isContentInteractiveView(view) && regions.includes(COCKPIT_REGIONS.CONTENT)) {
+    return COCKPIT_REGIONS.CONTENT;
+  }
+  if (regions.includes(COCKPIT_REGIONS.NAV)) return COCKPIT_REGIONS.NAV;
+  return regions[0] ?? COCKPIT_REGIONS.CONTENT;
+}
+
+export function interactiveRegionsFor(state) {
+  const regions = regionsForLayout(state.layoutMode);
+  if (!isContentInteractiveView(state.view) || state.view === ORCHESTRATOR_VIEWS.RUN_DETAIL) {
+    return regions.filter((region) => region === COCKPIT_REGIONS.NAV);
+  }
+  return regions.filter(
+    (region) => region === COCKPIT_REGIONS.NAV || region === COCKPIT_REGIONS.CONTENT
+  );
+}
+
+export function canTabBetweenRegions(state) {
+  if (!isContentInteractiveView(state.view)) return false;
+  if (state.view === ORCHESTRATOR_VIEWS.RUN_DETAIL) return false;
+  return interactiveRegionsFor(state).length >= 2;
+}
+
+/**
+ * Map raw key intent to a reducer action (or null when inactive / view-owned).
+ */
+export function routeCockpitKey(state, keyAction) {
+  switch (keyAction.type) {
+    case "escape":
+      return { type: "escape" };
+    case "tab":
+      return canTabBetweenRegions(state) ? { type: "tab" } : null;
+    case "arrow": {
+      if (state.region === COCKPIT_REGIONS.SYSTEM) return null;
+      if (state.region === COCKPIT_REGIONS.NAV || isNavFocusedView(state.view)) {
+        return { type: "arrow", direction: keyAction.direction };
+      }
+      if (state.region === COCKPIT_REGIONS.CONTENT && isContentInteractiveView(state.view)) {
+        if (state.view === ORCHESTRATOR_VIEWS.RUN_DETAIL || state.view === ORCHESTRATOR_VIEWS.LAUNCH) {
+          return null;
+        }
+        return {
+          type: "arrow",
+          direction: keyAction.direction,
+          listLength: keyAction.listLength
+        };
+      }
+      return null;
+    }
+    case "enter":
+      if (state.region === COCKPIT_REGIONS.NAV || isNavFocusedView(state.view)) {
+        return { type: "enter-nav" };
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+
+export function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+export { COCKPIT_NAV, COCKPIT_REGIONS, LAYOUT_MODES, ORCHESTRATOR_VIEWS, regionsForLayout };