@bodhiapp/setup-modal-types 0.0.1

package/extension.ts

@@ -0,0 +1,31 @@
+// Extension error codes
+export type ExtensionErrorCode = 'ext-not-installed' | 'ext-connection-failed' | 'ext-unsupported-version';
+
+// Extension error code constants
+export const EXT_NOT_INSTALLED: ExtensionErrorCode = 'ext-not-installed';
+export const EXT_CONNECTION_FAILED: ExtensionErrorCode = 'ext-connection-failed';
+export const EXT_UNSUPPORTED_VERSION: ExtensionErrorCode = 'ext-unsupported-version';
+
+// Extension state interfaces
+export interface ExtensionStateReady {
+  /** Current extension status */
+  status: 'ready';
+  /** Extension version */
+  version: string;
+  /** Extension ID (always present when ready) */
+  id: string;
+}
+
+export interface ExtensionStateNotReady {
+  /** Current extension status */
+  status: 'unreachable' | 'not-installed' | 'unsupported';
+  /** Error details */
+  error: {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code: ExtensionErrorCode;
+  };
+}
+
+export type ExtensionState = ExtensionStateReady | ExtensionStateNotReady;

package/index.ts

@@ -0,0 +1,84 @@
+/**
+ * Consolidated types for setup-modal
+ *
+ * This folder contains all domain and protocol types organized by domain.
+ * It is designed to be independent and copyable to other packages.
+ */
+
+// Platform types
+export type { BrowserType, OSType, EnvState, SupportedBrowser, NotSupportedBrowser, Browser, SupportedOS, NotSupportedOS, OS } from './platform';
+
+// Extension types
+export type { ExtensionErrorCode, ExtensionStateReady, ExtensionStateNotReady, ExtensionState } from './extension';
+export { EXT_NOT_INSTALLED, EXT_CONNECTION_FAILED, EXT_UNSUPPORTED_VERSION } from './extension';
+
+// Server types
+export type { ServerErrorCode, ServerStateReady, ServerStateReachable, ServerStatePending, ServerStateUnreachable, ServerStateError, ServerState } from './server';
+export {
+  SERVER_PENDING_EXT_READY,
+  SERVER_CONN_REFUSED,
+  SERVER_CONN_TIMEOUT,
+  SERVER_NOT_FOUND,
+  SERVER_NETWORK_UNREACHABLE,
+  SERVER_SERVICE_UNAVAILABLE,
+  SERVER_UNEXPECTED_ERROR,
+  SERVER_IN_SETUP_STATUS,
+  SERVER_IN_ADMIN_STATUS,
+} from './server';
+
+// LNA types
+export type {
+  LnaErrorCode,
+  LnaStatePrompt,
+  LnaStateSkipped,
+  LnaStateGranted,
+  LnaStateUnreachable,
+  LnaStateDenied,
+  LnaStateUnsupported,
+  LnaState,
+  LnaServerStatePending,
+  LnaServerStateReady,
+  LnaServerStateSetup,
+  LnaServerStateResourceAdmin,
+  LnaServerStateError,
+  LnaServerState,
+} from './lna';
+export { LNA_UNREACHABLE, LNA_PERMISSION_DENIED } from './lna';
+
+// State types
+export { SetupStep, DEFAULT_USER_CONFIRMATIONS, DEFAULT_SETUP_STATE } from './state';
+export type { SelectedConnection, UserConfirmations, SetupState } from './state';
+
+// Protocol types
+export type { RequestId, MessageKind, RequestMessage, ResponseMessage, ErrorMessage, EventMessage, ProtocolMessage } from './protocol';
+export { isRequestMessage, isResponseMessage, isErrorMessage, isEventMessage } from './protocol';
+
+// Message types
+export type { MessageTypeRegistry, MessageType, RequestPayload, ResponsePayload, RequestHandlers } from './message-types';
+export { MSG, isMessageType } from './message-types';
+
+// Type guards
+export {
+  isExtensionStateReady,
+  isExtensionStateNotReady,
+  isServerStateReady,
+  isServerStateReachable,
+  isServerStatePending,
+  isServerStateUnreachable,
+  isServerStateError,
+  isLnaStatePrompt,
+  isLnaStateSkipped,
+  isLnaStateGranted,
+  isLnaStateUnreachable,
+  isLnaStateDenied,
+  isLnaStateUnsupported,
+  isLnaServerStatePending,
+  isLnaServerStateReady,
+  isLnaServerStateSetup,
+  isLnaServerStateResourceAdmin,
+  isLnaServerStateError,
+  isSupportedBrowser,
+  isNotSupportedBrowser,
+  isSupportedOS,
+  isNotSupportedOS,
+} from './type-guards';

package/lna.ts

@@ -0,0 +1,75 @@
+// LNA error codes
+export type LnaErrorCode = 'lna-unreachable' | 'lna-permission-denied';
+
+// LNA error code constants
+export const LNA_UNREACHABLE: LnaErrorCode = 'lna-unreachable';
+export const LNA_PERMISSION_DENIED: LnaErrorCode = 'lna-permission-denied';
+
+// LNA (Local Network Access) state interfaces
+// Aligned with browser permission API states: prompt, granted, denied
+export interface LnaStatePrompt {
+  status: 'prompt';
+  serverUrl?: string; // For URL input default from localStorage
+}
+
+export interface LnaStateSkipped {
+  status: 'skipped';
+  serverUrl?: string; // For URL input default from localStorage
+}
+
+export interface LnaStateGranted {
+  status: 'granted';
+  serverUrl: string;
+}
+
+export interface LnaStateUnreachable {
+  status: 'unreachable';
+  serverUrl: string;
+  error: {
+    message: string;
+    code: LnaErrorCode;
+  };
+}
+
+export interface LnaStateDenied {
+  status: 'denied';
+  error: {
+    message: string;
+    code: LnaErrorCode;
+  };
+}
+
+export interface LnaStateUnsupported {
+  status: 'unsupported';
+}
+
+export type LnaState = LnaStatePrompt | LnaStateSkipped | LnaStateGranted | LnaStateUnreachable | LnaStateDenied | LnaStateUnsupported;
+
+// LNA Server state interfaces
+export interface LnaServerStatePending {
+  status: 'pending-lna-ready';
+}
+
+export interface LnaServerStateReady {
+  status: 'ready';
+  version: string;
+}
+
+export interface LnaServerStateSetup {
+  status: 'setup';
+  version: string;
+}
+
+export interface LnaServerStateResourceAdmin {
+  status: 'resource-admin';
+  version: string;
+}
+
+export interface LnaServerStateError {
+  status: 'error';
+  error: {
+    message: string;
+  };
+}
+
+export type LnaServerState = LnaServerStatePending | LnaServerStateReady | LnaServerStateSetup | LnaServerStateResourceAdmin | LnaServerStateError;

package/message-types.ts

@@ -0,0 +1,185 @@
+/**
+ * Message Type Registry - Single source of truth for all protocol message types
+ *
+ * This registry maps message type strings to their payload/response shapes.
+ * All other types (RequestPayload, ResponsePayload, etc.) are derived from this registry.
+ *
+ * Design: Each entry defines:
+ * - request: The payload type sent with the request
+ * - response: The payload type expected in the response
+ *
+ * For events (one-way messages), response is void.
+ */
+
+import type { SetupState } from './state';
+
+/**
+ * Central registry mapping message types to their payload/response shapes
+ * Single source of truth - everything else is inferred!
+ */
+export interface MessageTypeRegistry {
+  // === Modal → Parent (Commands) ===
+
+  /**
+   * Modal is ready and requesting initial state
+   * Sent on modal mount
+   */
+  'modal:ready': {
+    request: void;
+    response: { setupState: SetupState };
+  };
+
+  /**
+   * User requested to refresh platform detection
+   * Triggers re-detection of browser, OS, extension, server
+   */
+  'modal:refresh': {
+    request: void;
+    response: { setupState: SetupState };
+  };
+
+  /**
+   * User requested to close the modal
+   * Parent should hide/destroy modal
+   */
+  'modal:close': {
+    request: void;
+    response: void;
+  };
+
+  /**
+   * Setup completed successfully
+   * Signals parent that user has finished setup
+   */
+  'modal:complete': {
+    request: void;
+    response: void;
+  };
+
+  /**
+   * User requested LNA connection to specific server URL
+   * Triggers LNA permission request and connection attempt
+   */
+  'modal:lna:connect': {
+    request: { serverUrl: string };
+    response: { success: boolean };
+  };
+
+  /**
+   * User chose to skip LNA setup
+   * Falls back to extension-only mode
+   */
+  'modal:lna:skip': {
+    request: void;
+    response: { success: boolean };
+  };
+
+  /**
+   * User confirmed server installation status
+   * Used when server needs to be installed
+   */
+  'modal:confirm-server-install': {
+    request: { confirmed: boolean };
+    response: { success: boolean };
+  };
+
+  /**
+   * User selected preferred connection method
+   * Allows choosing between LNA and Extension paths
+   */
+  'modal:select-connection': {
+    request: { connection: 'lna' | 'extension' };
+    response: { success: boolean };
+  };
+
+  // === Parent → Modal (Events) ===
+
+  /**
+   * Parent sending updated state to modal
+   * Fired when platform detection results change
+   */
+  'parent:state-update': {
+    request: { setupState: SetupState };
+    response: void;
+  };
+}
+
+// === Derived Types with Full Inference ===
+
+/**
+ * Union of all valid message type strings
+ * Derived from MessageTypeRegistry keys
+ */
+export type MessageType = keyof MessageTypeRegistry;
+
+/**
+ * Extract request payload type for a given message type
+ * Returns the 'request' field from the registry entry
+ */
+export type RequestPayload<T extends MessageType> = MessageTypeRegistry[T]['request'];
+
+/**
+ * Extract response payload type for a given message type
+ * Returns the 'response' field from the registry entry
+ */
+export type ResponsePayload<T extends MessageType> = MessageTypeRegistry[T]['response'];
+
+/**
+ * Message type constants - Type-safe identifiers
+ *
+ * @example
+ * switch (message.type) {
+ *   case MSG.MODAL_READY:
+ *     // Type-safe constant, no typos possible
+ *     break;
+ * }
+ */
+export const MSG = {
+  // Modal lifecycle
+  MODAL_READY: 'modal:ready',
+  MODAL_REFRESH: 'modal:refresh',
+  MODAL_CLOSE: 'modal:close',
+  MODAL_COMPLETE: 'modal:complete',
+
+  // LNA actions
+  MODAL_LNA_CONNECT: 'modal:lna:connect',
+  MODAL_LNA_SKIP: 'modal:lna:skip',
+
+  // Server confirmation
+  MODAL_CONFIRM_SERVER_INSTALL: 'modal:confirm-server-install',
+
+  // Connection selection
+  MODAL_SELECT_CONNECTION: 'modal:select-connection',
+
+  // Parent → Modal events
+  PARENT_STATE_UPDATE: 'parent:state-update',
+} as const;
+
+/**
+ * Type guard that narrows RequestMessage to specific type WITH payload typing
+ *
+ * Use this for full type safety when you need access to typed payload fields.
+ * The guard narrows the generic RequestMessage to RequestMessage<T> where T
+ * determines the payload type.
+ *
+ * @example
+ * if (isMessageType(msg, MSG.MODAL_LNA_CONNECT)) {
+ *   // msg.payload is { serverUrl: string } - fully typed!
+ *   console.log(msg.payload.serverUrl); // Autocomplete works!
+ * }
+ */
+export function isMessageType<T extends MessageType>(msg: { type: string }, type: T): msg is { type: T } {
+  return msg.type === type;
+}
+
+/**
+ * Type-safe request handler map
+ * Enforces correct payload access AND correct return type for each message
+ *
+ * Each handler receives a RequestMessage<K> where K is the specific message type,
+ * providing full type safety for payload access. The handler must return the
+ * correct ResponsePayload<K> type.
+ */
+export type RequestHandlers = {
+  [K in MessageType]?: (msg: { type: K; requestId: string; payload: RequestPayload<K> }) => ResponsePayload<K>;
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@bodhiapp/setup-modal-types",
+  "version": "0.0.1",
+  "description": "TypeScript types for Bodhi Setup Modal",
+  "type": "module",
+  "main": "index.ts",
+  "types": "index.ts",
+  "exports": {
+    ".": {
+      "types": "./index.ts",
+      "import": "./index.ts",
+      "require": "./index.ts"
+    }
+  },
+  "files": [
+    "*.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BodhiSearch/bodhi-browser.git",
+    "directory": "setup-modal/src/types"
+  },
+  "license": "MIT",
+  "author": "BodhiSearch",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/platform.ts

@@ -0,0 +1,43 @@
+// Browser and OS type definitions
+export type BrowserType = 'chrome' | 'edge' | 'firefox' | 'safari' | 'unknown';
+export type OSType = 'macos' | 'windows' | 'linux' | 'unknown';
+
+// Environment state interface
+export interface EnvState {
+  os: OSType;
+  browser: BrowserType;
+}
+
+// Browser platform definitions
+export interface SupportedBrowser {
+  id: BrowserType;
+  status: 'supported';
+  name: string;
+  extension_url: string;
+}
+
+export interface NotSupportedBrowser {
+  id: BrowserType;
+  status: 'not-supported';
+  name: string;
+  github_issue_url?: string;
+}
+
+export type Browser = SupportedBrowser | NotSupportedBrowser;
+
+// OS platform definitions
+export interface SupportedOS {
+  id: OSType;
+  status: 'supported';
+  name: string;
+  download_url: string;
+}
+
+export interface NotSupportedOS {
+  id: OSType;
+  status: 'not-supported';
+  name: string;
+  github_issue_url?: string;
+}
+
+export type OS = SupportedOS | NotSupportedOS;

package/protocol.ts

@@ -0,0 +1,97 @@
+/**
+ * Core protocol types for setup-modal ↔ parent communication
+ *
+ * Design principles:
+ * - Type-safe request/response correlation
+ * - Discriminated unions for message kinds
+ * - Branded types for ID safety
+ * - Full TypeScript inference from MessageTypeRegistry
+ */
+
+import type { MessageType, RequestPayload, ResponsePayload } from './message-types';
+
+/** Branded type for type-safe request IDs */
+export type RequestId = string & { readonly __brand: 'RequestId' };
+
+/** Message kind discriminator */
+export type MessageKind = 'request' | 'response' | 'error' | 'event';
+
+/**
+ * Request message - expects a response
+ * Sent by either modal or parent to request an action
+ */
+export interface RequestMessage<T extends MessageType = MessageType> {
+  readonly kind: 'request';
+  readonly type: T;
+  readonly requestId: RequestId;
+  readonly payload: RequestPayload<T>;
+}
+
+/**
+ * Response message - correlates to a request
+ * Sent in response to a RequestMessage with matching requestId
+ */
+export interface ResponseMessage<T extends MessageType = MessageType> {
+  readonly kind: 'response';
+  readonly type: T;
+  readonly requestId: RequestId;
+  readonly payload: ResponsePayload<T>;
+}
+
+/**
+ * Error response - indicates request failure
+ * Sent instead of ResponseMessage when request cannot be fulfilled
+ */
+export interface ErrorMessage {
+  readonly kind: 'error';
+  readonly requestId: RequestId;
+  readonly error: {
+    code: string;
+    message: string;
+    details?: unknown;
+  };
+}
+
+/**
+ * Event message - fire-and-forget notification
+ * No response expected, used for one-way state updates
+ */
+export interface EventMessage<T extends MessageType = MessageType> {
+  readonly kind: 'event';
+  readonly type: T;
+  readonly payload: RequestPayload<T>;
+}
+
+/**
+ * Union of all protocol messages
+ * Discriminated by 'kind' field for type narrowing
+ */
+export type ProtocolMessage = RequestMessage | ResponseMessage | ErrorMessage | EventMessage;
+
+/**
+ * Type guard to check if message is a request
+ */
+export function isRequestMessage(msg: ProtocolMessage): msg is RequestMessage {
+  return msg.kind === 'request';
+}
+
+/**
+ * Type guard to check if message is a response
+ */
+export function isResponseMessage(msg: ProtocolMessage): msg is ResponseMessage {
+  return msg.kind === 'response';
+}
+
+/**
+ * Type guard to check if message is an error
+ */
+export function isErrorMessage(msg: ProtocolMessage): msg is ErrorMessage {
+  return msg.kind === 'error';
+}
+
+/**
+ * Type guard to check if message is an event
+ */
+export function isEventMessage(msg: ProtocolMessage): msg is EventMessage {
+  return msg.kind === 'event';
+}

package/server.ts

@@ -0,0 +1,82 @@
+// Server error codes
+export type ServerErrorCode =
+  | 'server-pending-ext-ready'
+  | 'server-conn-refused'
+  | 'server-conn-timeout'
+  | 'server-not-found'
+  | 'server-network-unreachable'
+  | 'server-service-unavailable'
+  | 'server-unexpected-error'
+  | 'server-in-setup-status'
+  | 'server-in-admin-status';
+
+// Server error code constants
+export const SERVER_PENDING_EXT_READY: ServerErrorCode = 'server-pending-ext-ready';
+export const SERVER_CONN_REFUSED: ServerErrorCode = 'server-conn-refused';
+export const SERVER_CONN_TIMEOUT: ServerErrorCode = 'server-conn-timeout';
+export const SERVER_NOT_FOUND: ServerErrorCode = 'server-not-found';
+export const SERVER_NETWORK_UNREACHABLE: ServerErrorCode = 'server-network-unreachable';
+export const SERVER_SERVICE_UNAVAILABLE: ServerErrorCode = 'server-service-unavailable';
+export const SERVER_UNEXPECTED_ERROR: ServerErrorCode = 'server-unexpected-error';
+export const SERVER_IN_SETUP_STATUS: ServerErrorCode = 'server-in-setup-status';
+export const SERVER_IN_ADMIN_STATUS: ServerErrorCode = 'server-in-admin-status';
+
+// Server state interfaces
+export interface ServerStateReady {
+  /** Current server status */
+  status: 'ready';
+  /** Server version */
+  version: string;
+}
+
+export interface ServerStateReachable {
+  /** Current server status */
+  status: 'setup' | 'resource-admin';
+  /** Server version */
+  version: string;
+  /** Error details */
+  error: {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code: ServerErrorCode;
+  };
+}
+
+export interface ServerStatePending {
+  /** Current server status */
+  status: 'pending-extension-ready';
+  /** Error details */
+  error: {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code: ServerErrorCode;
+  };
+}
+
+export interface ServerStateUnreachable {
+  /** Current server status */
+  status: 'unreachable';
+  /** Error details */
+  error: {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code: ServerErrorCode;
+  };
+}
+
+export interface ServerStateError {
+  /** Current server status */
+  status: 'error';
+  /** Error details */
+  error: {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code: ServerErrorCode;
+  };
+}
+
+export type ServerState = ServerStateReady | ServerStateReachable | ServerStatePending | ServerStateUnreachable | ServerStateError;

package/state.ts

@@ -0,0 +1,65 @@
+import type { Browser, EnvState, OS } from './platform';
+import type { ExtensionState } from './extension';
+import type { ServerState } from './server';
+import type { LnaServerState, LnaState } from './lna';
+
+// Step enum for navigation
+export enum SetupStep {
+  PLATFORM_CHECK = 'platform-check',
+  SERVER_SETUP = 'server-setup',
+  LNA_SETUP = 'lna-setup',
+  EXTENSION_SETUP = 'extension-setup',
+  COMPLETE = 'complete',
+}
+
+// Selected connection type for user preference
+export type SelectedConnection = 'lna' | 'extension' | null;
+
+// User confirmations interface for manual confirmation states
+export interface UserConfirmations {
+  /** Whether user has confirmed server installation */
+  serverInstall: boolean;
+}
+
+// Default user confirmations
+export const DEFAULT_USER_CONFIRMATIONS: UserConfirmations = {
+  serverInstall: false,
+};
+
+// Main setup state interface
+export interface SetupState {
+  /** Extension state details */
+  extension: ExtensionState;
+  /** Server state details (via extension) */
+  server: ServerState;
+  /** LNA connection state */
+  lna: LnaState;
+  /** Server state details (via LNA) */
+  lnaServer: LnaServerState;
+  /** Environment detection */
+  env: EnvState;
+  /** Browser platforms list */
+  browsers: Browser[];
+  /** Operating systems list */
+  os: OS[];
+  /** User confirmations for manual steps */
+  userConfirmations: UserConfirmations;
+  /** User's preferred connection method (null = auto-select based on priority) */
+  selectedConnection: SelectedConnection;
+}
+
+/**
+ * Default setup state used during initialization before parent sends real state
+ * Represents "loading" state - unknown platform, no extension, no server
+ */
+export const DEFAULT_SETUP_STATE: SetupState = {
+  extension: { status: 'not-installed', error: { message: 'Loading...', code: 'ext-not-installed' } },
+  server: { status: 'pending-extension-ready', error: { message: 'Loading...', code: 'server-pending-ext-ready' } },
+  lna: { status: 'prompt' },
+  lnaServer: { status: 'pending-lna-ready' },
+  env: { browser: 'unknown', os: 'unknown' },
+  browsers: [],
+  os: [],
+  userConfirmations: DEFAULT_USER_CONFIRMATIONS,
+  selectedConnection: null,
+};

package/type-guards.ts

@@ -0,0 +1,126 @@
+import type { ExtensionState, ExtensionStateNotReady, ExtensionStateReady } from './extension';
+import type { ServerState, ServerStateError, ServerStatePending, ServerStateReachable, ServerStateReady, ServerStateUnreachable } from './server';
+import type {
+  LnaServerState,
+  LnaServerStateError,
+  LnaServerStatePending,
+  LnaServerStateReady,
+  LnaServerStateResourceAdmin,
+  LnaServerStateSetup,
+  LnaState,
+  LnaStateDenied,
+  LnaStateGranted,
+  LnaStatePrompt,
+  LnaStateSkipped,
+  LnaStateUnreachable,
+  LnaStateUnsupported,
+} from './lna';
+import type { Browser, NotSupportedBrowser, NotSupportedOS, OS, SupportedBrowser, SupportedOS } from './platform';
+
+// ============================================
+// Extension Type Guards
+// ============================================
+
+export function isExtensionStateReady(ext: ExtensionState): ext is ExtensionStateReady {
+  return ext.status === 'ready';
+}
+
+export function isExtensionStateNotReady(ext: ExtensionState): ext is ExtensionStateNotReady {
+  return ext.status !== 'ready';
+}
+
+// ============================================
+// Server Type Guards
+// ============================================
+
+export function isServerStateReady(server: ServerState): server is ServerStateReady {
+  return server.status === 'ready';
+}
+
+export function isServerStateReachable(server: ServerState): server is ServerStateReachable {
+  return server.status === 'setup' || server.status === 'resource-admin';
+}
+
+export function isServerStatePending(server: ServerState): server is ServerStatePending {
+  return server.status === 'pending-extension-ready';
+}
+
+export function isServerStateUnreachable(server: ServerState): server is ServerStateUnreachable {
+  return server.status === 'unreachable';
+}
+
+export function isServerStateError(server: ServerState): server is ServerStateError {
+  return server.status === 'error';
+}
+
+// ============================================
+// LNA Type Guards
+// ============================================
+
+export function isLnaStatePrompt(lna: LnaState): lna is LnaStatePrompt {
+  return lna.status === 'prompt';
+}
+
+export function isLnaStateSkipped(lna: LnaState): lna is LnaStateSkipped {
+  return lna.status === 'skipped';
+}
+
+export function isLnaStateGranted(lna: LnaState): lna is LnaStateGranted {
+  return lna.status === 'granted';
+}
+
+export function isLnaStateUnreachable(lna: LnaState): lna is LnaStateUnreachable {
+  return lna.status === 'unreachable';
+}
+
+export function isLnaStateDenied(lna: LnaState): lna is LnaStateDenied {
+  return lna.status === 'denied';
+}
+
+export function isLnaStateUnsupported(lna: LnaState): lna is LnaStateUnsupported {
+  return lna.status === 'unsupported';
+}
+
+// ============================================
+// LNA Server Type Guards
+// ============================================
+
+export function isLnaServerStatePending(server: LnaServerState): server is LnaServerStatePending {
+  return server.status === 'pending-lna-ready';
+}
+
+export function isLnaServerStateReady(server: LnaServerState): server is LnaServerStateReady {
+  return server.status === 'ready';
+}
+
+export function isLnaServerStateSetup(server: LnaServerState): server is LnaServerStateSetup {
+  return server.status === 'setup';
+}
+
+export function isLnaServerStateResourceAdmin(server: LnaServerState): server is LnaServerStateResourceAdmin {
+  return server.status === 'resource-admin';
+}
+
+export function isLnaServerStateError(server: LnaServerState): server is LnaServerStateError {
+  return server.status === 'error';
+}
+
+// ============================================
+// Browser/OS Type Guards
+// ============================================
+
+export function isSupportedBrowser(browser: Browser): browser is SupportedBrowser {
+  return browser.status === 'supported';
+}
+
+export function isNotSupportedBrowser(browser: Browser): browser is NotSupportedBrowser {
+  return browser.status === 'not-supported';
+}
+
+export function isSupportedOS(os: OS): os is SupportedOS {
+  return os.status === 'supported';
+}
+
+export function isNotSupportedOS(os: OS): os is NotSupportedOS {
+  return os.status === 'not-supported';
+}