@qodalis/cli 2.0.0-beta.2 → 2.0.0-beta.20

package/public-api.d.mts

@@ -1,8 +1,10 @@
-import * as _qodalis_cli_core from '@qodalis/cli-core';
-import { ICliCommandProcessor, ICliCommandParameterDescriptor, ICliCommandProcessorRegistry, ICliCommandChildProcessor, CliProcessorMetadata, CliStateConfiguration, ICliExecutionContext, CliProcessCommand, ICliCommandAuthor, CliThemeInfo, ICliExecutionProcess, ICliUserSession, ICliSpinner, ICliPercentageProgressBar, ICliTextAnimator, ICliTerminalWriter, ICliCommandExecutorService, ICliClipboard, ICliStateStore, CliOptions, ICliLogger, ICliServiceProvider, ICliTranslationService, ICliInputReader, ICliBackgroundServiceRegistry, ICliManagedInterval, ICliManagedTimer, ICliKeyValueStore, CliSelectOption, CliMultiSelectOption, ICliCompletionProvider, ICliGlobalParameterHandler, CliProvider, CliForegroundColor, CliBackgroundColor, CliLogLevel, CliPercentageProgressBarUpdateValueOptions, CliTextAnimatorOptions, ICliModule, CliModuleRegistry, Package, ICliPingServerService, ICliProcessRegistry, ICliProcessEntry, ICliDragDropService, CliState, CliEngineSnapshot, CliServerConfig, CliServerCommandDescriptor, CliServerCapabilities, CliServerResponse, CliIcon } from '@qodalis/cli-core';
+import { ICliCommandProcessor, ICliCommandParameterDescriptor as ICliCommandParameterDescriptor$1, ICliCommandProcessorRegistry, ICliCommandChildProcessor, CliProcessorMetadata, CliStateConfiguration, ICliExecutionContext, CliProcessCommand, ICliCommandAuthor, CliThemeInfo, ICliExecutionProcess, ICliUserSession, ICliSpinner, ICliPercentageProgressBar, ICliTextAnimator, ICliTerminalWriter, ICliCommandExecutorService, ICliClipboard, ICliStateStore, CliOptions, ICliLogger, ICliServiceProvider, ICliTranslationService, ICliInputReader, ICliBackgroundServiceRegistry, ICliHttpClient, ICliNotifier, ICliManagedInterval, ICliManagedTimer, ICliEventBus, ICliKeyValueStore, CliStateStoreOptions, ICliCompletionProvider, ICliFilePickerProvider, CliFullScreenOptions, ICliProcessRegistry, ICliBackgroundService, ICliServiceContext, ICliBackgroundServiceInfo, ICliServiceLogEntry, CliServiceEventHandler, ICliGlobalParameterHandler, CliForegroundColor, CliBackgroundColor, CliToken, CliProvider, CliTableOptions, CliLogLevel, CliPercentageProgressBarUpdateValueOptions, CliTextAnimatorOptions, ICliModule, CliModuleRegistry, Package, ICliPingServerService, CliLineOptions, CliSelectOption, CliSelectOptions, CliMultiSelectOption, CliMultiSelectOptions, CliNumberOptions, CliDateOptions, CliFilePickerOptions, CliFileResult, ICliProcessRegisterOptions, ICliProcessEntry, ICliDragDropService, CliHttpRequestOptions, CliNotification, ICliPermissionRegistry, CliPermissionDefinition, CliState, CliEngineSnapshot, CliEvent, CliEventType, CliEventMap, CliEmitOptions, CustomEventType, CliEventHandler, CliServerConfig, ICliServerAuthService, CliServerCommandDescriptor, CliServerCapabilities, CliServerResponse, CliServerOutput, CliPanelPosition, CliPanelConfig, CliPanelHideAlignment, ICliPanelRef, CliPanelState } from '@qodalis/cli-core';
 export { ICliUserSessionService_TOKEN, ICliUsersStoreService_TOKEN } from '@qodalis/cli-core';
 import { ITheme, Terminal, ITerminalAddon, ITerminalOptions, ITerminalInitOnlyOptions } from '@xterm/xterm';
+import * as rxjs from 'rxjs';
 import { Subject, Observable, Subscription } from 'rxjs';
+import { FitAddon } from '@xterm/addon-fit';
+import { SerializeAddon } from '@xterm/addon-serialize';
 
 type ParsedArg = {
     name: string;
@@ -13,6 +15,8 @@ type ParsedToken = {
     name: string;
     value: string | number | boolean;
     hasEquals: boolean;
+    /** Written with one dash (`-rf`), so it may be several short flags */
+    short?: boolean;
 } | {
     kind: 'word';
     value: string;
@@ -70,7 +74,7 @@ declare class CliArgsParser {
  * @param descriptors - Parameter descriptors from the matched processor.
  * @returns Reconciled args array and remaining command parts.
  */
-declare function reconcileArgs(tokens: ParsedToken[], descriptors: ICliCommandParameterDescriptor[] | undefined): {
+declare function reconcileArgs(tokens: ParsedToken[], descriptors: ICliCommandParameterDescriptor$1[] | undefined): {
     args: ParsedArg[];
     commandParts: string[];
 };
@@ -88,6 +92,11 @@ declare class ProcessExitedError extends Error {
 
 declare class CliCommandProcessorRegistry implements ICliCommandProcessorRegistry {
     readonly processors: ICliCommandProcessor[];
+    /**
+     * Sub-commands each extension (`extendsProcessor`) merged into an
+     * existing command, removed again when the extension is unregistered.
+     */
+    private readonly mergedByExtension;
     constructor(initialProcessors?: ICliCommandProcessor[]);
     registerProcessor(processor: ICliCommandProcessor): void;
     unregisterProcessor(processor: ICliCommandProcessor): void;
@@ -108,73 +117,82 @@ declare class CliCommandProcessorRegistry implements ICliCommandProcessorRegistr
  * Framework-agnostic token for the CLI command processor registry.
  * Used as a key in the service provider to retrieve the registry.
  */
-declare const CliProcessorsRegistry_TOKEN = "cli-processors-registry";
+declare const CliProcessorsRegistry_TOKEN: any;
 /**
  * Framework-agnostic token for the CLI state store manager.
  * Used as a key in the service provider to retrieve the state store manager.
  */
-declare const CliStateStoreManager_TOKEN = "cli-state-store-manager";
+declare const CliStateStoreManager_TOKEN: any;
 /**
  * Framework-agnostic token for the CLI command history service.
  * Used as a key in the service provider to retrieve the command history.
  */
-declare const CliCommandHistory_TOKEN = "cli-command-history";
+declare const CliCommandHistory_TOKEN: any;
 /**
  * Framework-agnostic token for the CLI ping server service.
  * Used as a key in the service provider to retrieve the ping server service.
  */
-declare const ICliPingServerService_TOKEN = "cli-ping-server-service";
+declare const ICliPingServerService_TOKEN: any;
 /**
  * Framework-agnostic token for the CLI module registry.
  * Used as a key in the service provider to retrieve the module registry.
  */
-declare const CliModuleRegistry_TOKEN = "cli-module-registry";
+declare const CliModuleRegistry_TOKEN: any;
+/**
+ * The live boot report (`CliBootLog`) while the CLI starts. Processors and
+ * modules can add steps and lines from `initialize`/`onInit`; it ignores
+ * entries once boot has finished.
+ */
+declare const CliBootLog_TOKEN: any;
 /**
  * Framework-agnostic token for the CLI background service registry.
  * Used as a key in the service provider to retrieve the background service registry.
  */
-declare const CliBackgroundServiceRegistry_TOKEN = "cli-background-service-registry";
+declare const CliBackgroundServiceRegistry_TOKEN: any;
 /**
  * Framework-agnostic token for the CLI package manager service.
  * Used as a key in the service provider to retrieve the package manager.
  */
-declare const CliPackageManagerService_TOKEN = "cli-package-manager-service";
+declare const CliPackageManagerService_TOKEN: any;
+/**
+ * Framework-agnostic token for the CLI key-value store.
+ * Used as a key in the service provider to retrieve the persistent storage.
+ */
+declare const CliKeyValueStore_TOKEN: any;
+/**
+ * Framework-agnostic token for the syntax highlighter registry.
+ * Used as a key in the service provider to retrieve the syntax highlighter registry.
+ */
+declare const SyntaxHighlighterRegistry_TOKEN: any;
 
-declare const LIBRARY_VERSION = "2.0.0-beta.2";
+declare const LIBRARY_VERSION = "2.0.0-beta.20";
 declare const API_VERSION = 2;
 
 declare class CliAliasCommandProcessor implements ICliCommandProcessor {
     command: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     description: string;
-    processors?: ICliCommandProcessor[] | undefined;
+    acceptsRawInput: boolean;
     metadata?: CliProcessorMetadata | undefined;
     stateConfiguration?: CliStateConfiguration | undefined;
+    /** Shared aliases (used when no auth module is loaded) */
     userAliases: Record<string, string>;
+    private aliasState;
+    /** Aliases visible to the current principal */
+    aliasesFor(context: Pick<ICliExecutionContext, 'services'>): Record<string, string>;
     private stateSubscription?;
-    constructor();
+    /** `alias ls`: list the aliases visible to the current principal */
+    private listAliases;
     writeDescription(context: ICliExecutionContext): void;
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     initialize(context: ICliExecutionContext): Promise<void>;
 }
 
-declare class CliBase64CommandProcessor implements ICliCommandProcessor {
-    command: string;
-    aliases: string[];
-    description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
-    processors?: ICliCommandProcessor[];
-    metadata?: CliProcessorMetadata;
-    constructor();
-    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
-    writeDescription(context: ICliExecutionContext): void;
-}
-
 declare class CliCalCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata;
     parameters: {
         name: string;
@@ -191,7 +209,7 @@ declare class CliClearCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description?: string | undefined;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata | undefined;
     processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
@@ -201,7 +219,7 @@ declare class CliClipboardCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     processors?: ICliCommandProcessor[];
     metadata?: CliProcessorMetadata;
     constructor();
@@ -213,7 +231,7 @@ declare class CliColorCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     valueRequired: boolean;
     metadata?: CliProcessorMetadata;
@@ -231,7 +249,7 @@ declare class CliConvertCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     valueRequired: boolean;
     metadata?: CliProcessorMetadata;
@@ -247,11 +265,9 @@ declare class CliEchoCommandProcessor implements ICliCommandProcessor {
     aliases: string[];
     description: string;
     acceptsRawInput: boolean;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata | undefined;
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
-    /** Remove surrounding quotes from the text. */
-    private stripQuotes;
     /** Interpret common escape sequences like a POSIX echo -e. */
     private interpretEscapes;
     writeDescription(context: ICliExecutionContext): void;
@@ -261,63 +277,29 @@ declare class CliEvalCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     metadata?: CliProcessorMetadata | undefined;
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
 }
 
-declare class CliHashCommandProcessor implements ICliCommandProcessor {
-    command: string;
-    description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
-    processors?: ICliCommandProcessor[];
-    metadata?: CliProcessorMetadata;
-    constructor();
-    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
-    writeDescription(context: ICliExecutionContext): void;
-}
-
-declare class CliHexCommandProcessor implements ICliCommandProcessor {
-    command: string;
-    description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
-    processors?: ICliCommandProcessor[];
-    metadata?: CliProcessorMetadata;
-    constructor();
-    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
-    writeDescription(context: ICliExecutionContext): void;
-}
-
 declare class CliJsonCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
-    processors?: ICliCommandProcessor[];
-    metadata?: CliProcessorMetadata;
-    constructor();
-    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
-    writeDescription(context: ICliExecutionContext): void;
-}
-
-declare class CliJwtCommandProcessor implements ICliCommandProcessor {
-    command: string;
-    description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     processors?: ICliCommandProcessor[];
     metadata?: CliProcessorMetadata;
     constructor();
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
-    private base64UrlDecode;
 }
 
 declare class CliLoremCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     processors?: ICliCommandProcessor[];
     metadata?: CliProcessorMetadata;
     constructor();
@@ -329,7 +311,7 @@ declare class CliLoremCommandProcessor implements ICliCommandProcessor {
 declare class CliOpenCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     valueRequired: boolean;
     metadata?: CliProcessorMetadata;
@@ -341,7 +323,7 @@ declare class CliRandomCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     processors?: ICliCommandProcessor[];
     metadata?: CliProcessorMetadata;
     constructor();
@@ -353,7 +335,7 @@ declare class CliScreenCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata;
     processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
@@ -363,7 +345,7 @@ declare class CliSeqCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     valueRequired: boolean;
     metadata?: CliProcessorMetadata;
@@ -388,7 +370,7 @@ declare class CliSleepCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description?: string | undefined;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata | undefined;
     valueRequired?: boolean | undefined;
     constructor();
@@ -400,7 +382,7 @@ declare class CliTimeCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     version: string;
     processors?: ICliCommandProcessor[] | undefined;
     metadata?: CliProcessorMetadata | undefined;
@@ -413,7 +395,7 @@ declare class CliTimestampCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     processors?: ICliCommandProcessor[];
     metadata?: CliProcessorMetadata;
     constructor();
@@ -423,7 +405,7 @@ declare class CliTimestampCommandProcessor implements ICliCommandProcessor {
 
 declare class CliUnAliasCommandProcessor implements ICliCommandProcessor {
     command: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     description: string;
     valueRequired?: boolean | undefined;
     stateConfiguration?: CliStateConfiguration | undefined;
@@ -436,7 +418,7 @@ declare class CliUnameCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description?: string | undefined;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata | undefined;
     writeDescription(context: ICliExecutionContext): void;
     processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
@@ -450,29 +432,17 @@ declare class CliUnameCommandProcessor implements ICliCommandProcessor {
 declare class CliUptimeCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata;
-    private sessionStartTimes;
     initialize(context: ICliExecutionContext): Promise<void>;
     processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
 }
 
-declare class CliUrlCommandProcessor implements ICliCommandProcessor {
-    command: string;
-    description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
-    processors?: ICliCommandProcessor[];
-    metadata?: CliProcessorMetadata;
-    constructor();
-    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
-    writeDescription(context: ICliExecutionContext): void;
-}
-
 declare class CliYesCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     metadata?: CliProcessorMetadata;
     parameters: {
@@ -486,14 +456,49 @@ declare class CliYesCommandProcessor implements ICliCommandProcessor {
     writeDescription(context: ICliExecutionContext): void;
 }
 
+/**
+ * `test EXPR` / `[ EXPR ]`: evaluate a condition; exit status 0 when true,
+ * 1 when false and 2 on an error. Used by `if`, `while` and `&&`/`||`.
+ */
+declare class CliTestCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: any;
+    acceptsRawInput: boolean;
+    metadata?: CliProcessorMetadata;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+/** `true`: do nothing, successfully (also `:`). */
+declare class CliTrueCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: any;
+    acceptsRawInput: boolean;
+    metadata?: CliProcessorMetadata;
+    processCommand(): Promise<void>;
+}
+/** `false`: do nothing, unsuccessfully (exit status 1). */
+declare class CliFalseCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: any;
+    acceptsRawInput: boolean;
+    metadata?: CliProcessorMetadata;
+    processCommand(_command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
 declare class CliCaptureCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
     aliases: string[];
     author: ICliCommandAuthor;
     metadata: CliProcessorMetadata;
-    parameters: ICliCommandParameterDescriptor[];
+    parameters: ICliCommandParameterDescriptor$1[];
     processCommand(cmd: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
     private sanitizeCssColor;
     private toHtml;
     private escapeHtml;
@@ -508,6 +513,7 @@ declare class CliSnippetCommandProcessor implements ICliCommandProcessor {
     metadata: CliProcessorMetadata;
     stateConfiguration: CliStateConfiguration;
     processors: ICliCommandChildProcessor[];
+    writeDescription(context: ICliExecutionContext): void;
     processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
 }
 
@@ -516,8 +522,9 @@ declare class CliDiffCommandProcessor implements ICliCommandProcessor {
     description: string;
     author: ICliCommandAuthor;
     metadata: CliProcessorMetadata;
-    parameters: ICliCommandParameterDescriptor[];
+    parameters: ICliCommandParameterDescriptor$1[];
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
 }
 
 type DiffType = 'same' | 'add' | 'remove';
@@ -539,11 +546,17 @@ declare class CliHelpCommandProcessor implements ICliCommandProcessor {
     aliases: string[];
     description: string;
     acceptsRawInput?: boolean | undefined;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata | undefined;
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
     private translateDescription;
+    /**
+     * Canonical path of the command being described (`server.status` for
+     * `help srv ping`), so a sub-command's translation keys include its
+     * parents: `cli.server.status.description`.
+     */
+    private commandPath;
     private writeProcessorDescription;
     private formatModuleName;
     private writeParameter;
@@ -589,44 +602,45 @@ declare class CliHotKeysCommandProcessor implements ICliCommandProcessor {
     aliases: string[];
     description: string;
     processors?: ICliCommandProcessor[] | undefined;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata | undefined;
     processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
 }
 
+/** `pkg`: install, update and remove CLI plugins at runtime from npm/CDN sources. */
 declare class CliPackagesCommandProcessor implements ICliCommandProcessor {
     readonly command = "pkg";
     readonly aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
-    readonly version = "1.0.3";
-    readonly processors?: ICliCommandProcessor[] | undefined;
+    author: any;
+    readonly version = "1.1.0";
+    readonly processors: ICliCommandProcessor[];
     readonly metadata?: CliProcessorMetadata | undefined;
     stateConfiguration?: CliStateConfiguration | undefined;
-    private registeredDependencies;
-    private scriptsLoader;
-    private packagesManager;
-    private registry;
-    private createAbortSignal;
+    private readonly loader;
+    private readonly manager;
+    private readonly installer;
     constructor();
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
-    writeDescription?(context: ICliExecutionContext): void;
+    writeDescription(context: ICliExecutionContext): void;
     initialize(context: ICliExecutionContext): Promise<void>;
-    private removePackage;
-    private addPackage;
-    private doAddPackage;
-    private updatePackage;
-    private injectScriptWithCdnFallback;
-    private registerPackageDependencies;
-    private resolvePackageCdnPath;
-    private waitForGlobal;
+    private lsCommand;
+    private browseCommand;
+    private addCommand;
+    private removeCommand;
+    private versionsCommand;
+    private checkCommand;
+    private updateCommand;
+    private sourceCommand;
+    /** Install as a tracked background job (visible in `services`), or inline if that fails. */
+    private installInBackground;
 }
 
 declare class CliDebugCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata?: CliProcessorMetadata;
     processors?: ICliCommandProcessor[];
     processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
@@ -638,7 +652,7 @@ declare class CliNanoCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     metadata: CliProcessorMetadata;
     private buffer;
@@ -657,6 +671,7 @@ declare class CliNanoCommandProcessor implements ICliCommandProcessor {
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     onData(data: string, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
+    private setupHighlighting;
     private render;
     private renderPrompt;
     private showStatus;
@@ -675,7 +690,7 @@ declare class CliServicesCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     processors?: ICliCommandProcessor[];
     metadata?: CliProcessorMetadata;
     constructor();
@@ -683,27 +698,81 @@ declare class CliServicesCommandProcessor implements ICliCommandProcessor {
     writeDescription(context: ICliExecutionContext): void;
 }
 
+/**
+ * `events`: inspect the terminal's event bus — watch events live, show the
+ * recent ones, or emit one (for testing plugins).
+ */
+declare class CliEventsCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: any;
+    version: string;
+    metadata?: CliProcessorMetadata;
+    processors: ICliCommandProcessor[];
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
 declare class CliPsCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     metadata: {
         icon: string;
         sealed: boolean;
     };
     processCommand(_command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
 }
 
 declare class CliKillCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     valueRequired: boolean;
     metadata: {
         icon: string;
         sealed: boolean;
     };
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliHtopCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: any;
+    metadata?: CliProcessorMetadata;
+    private context;
+    private registry;
+    private refreshTimer;
+    private rows;
+    private selectedIndex;
+    private scrollOffset;
+    private termCols;
+    private termRows;
+    private showingLogs;
+    private errorMessage;
+    private errorTimeout;
+    processCommand(_command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    onData(data: string, context: ICliExecutionContext): Promise<void>;
+    onResize(cols: number, rows: number, _context: ICliExecutionContext): void;
+    onDispose(_context: ICliExecutionContext): void;
+    writeDescription(context: ICliExecutionContext): void;
+    private refreshData;
+    private actionKill;
+    private actionStart;
+    private actionStop;
+    private actionRestart;
+    private actionLogs;
+    private moveSelection;
+    private get visibleRows();
+    private clampScroll;
+    private render;
+    private buildFooter;
+    private renderLogsOverlay;
+    private showError;
+    private exit;
 }
 
 declare const systemProcessors: ICliCommandProcessor[];
@@ -721,6 +790,8 @@ declare class CliThemeCommandProcessor implements ICliCommandProcessor {
     private defaultTheme;
     constructor();
     initialize(context: ICliExecutionContext): Promise<void>;
+    /** Apply the saved theme (or the default one when `reset` and none is saved). */
+    private applySavedTheme;
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     private renderThemePreview;
     private applyStyles;
@@ -732,39 +803,7 @@ type ThemeState = {
     selectedTheme?: string;
     customOptions?: ITheme;
 };
-declare const themes: {
-    [x: string]: ITheme;
-    default: ITheme;
-    classic: ITheme;
-    dracula: ITheme;
-    monokai: ITheme;
-    solarizedDark: ITheme;
-    solarizedLight: ITheme;
-    gruvboxDark: ITheme;
-    gruvboxLight: ITheme;
-    nord: ITheme;
-    oneDark: ITheme;
-    material: ITheme;
-    highContrastLight: ITheme;
-    tokyoNight: ITheme;
-    catppuccinMocha: ITheme;
-    catppuccinFrappe: ITheme;
-    rosePine: ITheme;
-    kanagawa: ITheme;
-    everforestDark: ITheme;
-    ayuDark: ITheme;
-    catppuccinLatte: ITheme;
-    rosePineDawn: ITheme;
-    everforestLight: ITheme;
-    githubLight: ITheme;
-    cyberpunk: ITheme;
-    retroGreen: ITheme;
-    retroAmber: ITheme;
-    matrix: ITheme;
-    synthwave: ITheme;
-    highContrastDark: ITheme;
-    yellow: ITheme;
-};
+declare const themes: any;
 declare const themeInfos: Record<string, CliThemeInfo>;
 
 declare class CliConfigureCommandProcessor implements ICliCommandProcessor {
@@ -784,7 +823,16 @@ declare class CliConfigureCommandProcessor implements ICliCommandProcessor {
     private editOption;
     private setConfigValue;
     private getConfigValue;
+    /**
+     * The language choices are the locales loaded so far: a language pack
+     * installed after boot (`pkg add @qodalis/cli-lang-de`) adds one.
+     */
+    private refreshLanguageOptions;
     private getAllOptions;
+    /**
+     * @param onBoot at startup, terminal options still at their default are skipped so the
+     *               host's `terminalOptions` (e.g. its own fontSize) are not overridden.
+     */
     private applySystemSettings;
     private buildListProcessor;
     private buildGetProcessor;
@@ -819,22 +867,39 @@ declare class CliPingCommandProcessor implements ICliCommandProcessor {
     private sleep;
 }
 
+/** Permission to change shared variables, when an auth module is loaded. */
+declare const CLI_ENV_GLOBAL_PERMISSION = "system:env:global";
+/** Parse `A=1 B="two words" C` into assignments; bare names have no value. */
+declare function parseAssignments(raw: string): {
+    name: string;
+    value?: string;
+}[] | null;
 /**
  * `export` — set environment variables.
  *
  * Usage:
  *   export VAR=value
- *   export VAR="value with spaces"
+ *   export VAR="value with spaces" OTHER=1
+ *
+ * Variables are saved for the signed-in user (`--global`: for everyone) and
+ * restored on the next visit. `NAME=value` alone is for this terminal only.
  */
 declare class CliExportCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     metadata: {
         icon: string;
         module: string;
     };
+    parameters: ICliCommandParameterDescriptor[];
+    stateConfiguration: CliStateConfiguration;
+    /**
+     * Restore saved variables, save every later change (export, unset) and
+     * follow changes saved in other tabs and terminals.
+     */
+    initialize(context: ICliExecutionContext): Promise<void>;
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
 }
@@ -844,12 +909,13 @@ declare class CliExportCommandProcessor implements ICliCommandProcessor {
 declare class CliUnsetCommandProcessor implements ICliCommandProcessor {
     command: string;
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     metadata: {
         icon: string;
         module: string;
     };
+    parameters: any[];
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     writeDescription(context: ICliExecutionContext): void;
 }
@@ -860,7 +926,7 @@ declare class CliEnvCommandProcessor implements ICliCommandProcessor {
     command: string;
     aliases: string[];
     description: string;
-    author: _qodalis_cli_core.ICliCommandAuthor;
+    author: any;
     acceptsRawInput: boolean;
     metadata: {
         icon: string;
@@ -878,13 +944,18 @@ declare class CliFontSizeCommandProcessor implements ICliCommandProcessor {
     metadata: CliProcessorMetadata;
     stateConfiguration: CliStateConfiguration;
     processors: ICliCommandProcessor[];
+    /** The size the host configured (or the built-in default), restored by `font-size reset`. */
+    private hostFontSize?;
     initialize(context: ICliExecutionContext): Promise<void>;
     processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
     private getCurrent;
+    private getDefault;
+    private resetFontSize;
     private setFontSize;
 }
 
-declare const miscProcessors: (CliAliasCommandProcessor | CliBase64CommandProcessor | CliCalCommandProcessor | CliClearCommandProcessor | CliClipboardCommandProcessor | CliColorCommandProcessor | CliConvertCommandProcessor | CliEchoCommandProcessor | CliEvalCommandProcessor | CliHashCommandProcessor | CliHexCommandProcessor | CliJsonCommandProcessor | CliJwtCommandProcessor | CliLoremCommandProcessor | CliOpenCommandProcessor | CliRandomCommandProcessor | CliScreenCommandProcessor | CliSeqCommandProcessor | CliSleepCommandProcessor | CliTimeCommandProcessor | CliTimestampCommandProcessor | CliUnAliasCommandProcessor | CliUnameCommandProcessor | CliUptimeCommandProcessor | CliUrlCommandProcessor | CliYesCommandProcessor)[];
+declare const miscProcessors: (CliClearCommandProcessor | CliEchoCommandProcessor | CliEvalCommandProcessor | CliAliasCommandProcessor | CliUnAliasCommandProcessor | CliSleepCommandProcessor | CliUnameCommandProcessor | CliTimeCommandProcessor | CliJsonCommandProcessor | CliRandomCommandProcessor | CliUptimeCommandProcessor | CliOpenCommandProcessor | CliLoremCommandProcessor | CliTimestampCommandProcessor | CliColorCommandProcessor | CliCalCommandProcessor | CliSeqCommandProcessor | CliScreenCommandProcessor | CliClipboardCommandProcessor | CliConvertCommandProcessor | CliYesCommandProcessor | CliTestCommandProcessor | CliTrueCommandProcessor | CliFalseCommandProcessor)[];
 declare const builtinProcessors: ICliCommandProcessor[];
 
 declare class CliExecutionProcess implements ICliExecutionProcess {
@@ -928,6 +999,8 @@ declare class CliCommandExecutionContext implements ICliExecutionContext {
     translator: ICliTranslationService;
     reader: ICliInputReader;
     readonly backgroundServices: ICliBackgroundServiceRegistry;
+    http: ICliHttpClient;
+    notifier: ICliNotifier;
     get promptLength(): number;
     set promptLength(value: number);
     get currentLine(): string;
@@ -946,14 +1019,35 @@ declare class CliCommandExecutionContext implements ICliExecutionContext {
     exitFullScreenMode: () => void;
     createInterval: (callback: () => void, ms: number) => ICliManagedInterval;
     createTimeout: (callback: () => void, ms: number) => ICliManagedTimer;
+    submitCommand: (command: string) => Promise<void>;
+    events?: ICliEventBus;
+    get isBooted(): boolean | undefined;
     constructor(context: ICliExecutionContext, processor: ICliCommandProcessor);
 }
 
+/**
+ * Command history, kept per user like a shell's `~/.bash_history`: each
+ * signed-in user (by id) has their own, and the shared one is used while
+ * nobody is signed in.
+ */
 declare class CliCommandHistory {
     private readonly store;
-    private readonly storageKey;
     private commandHistory;
+    /** Id of the user whose history is loaded; undefined: nobody signed in */
+    private userId;
+    private loading;
+    /** Counts user switches (a load for an older one is dropped) */
+    private switches;
+    private _generation;
     constructor(store: ICliKeyValueStore);
+    /** Changes whenever the history is replaced: switched or loaded (positions into it are stale) */
+    get generation(): number;
+    private get storageKey();
+    /**
+     * Switch to the history of `userId` (undefined: nobody signed in).
+     * Resolves once it is loaded; a no-op for the user already loaded.
+     */
+    useUser(userId: string | undefined): Promise<void>;
     addCommand(command: string): Promise<void>;
     getLastIndex(): number;
     getHistory(): string[];
@@ -984,7 +1078,7 @@ declare class CliCommandHistory {
 
 interface ICliStateStoreManager {
     getProcessorStateStore(processor: ICliCommandProcessor): ICliStateStore;
-    getStateStore(name: string, defaultState?: Record<string, any>): ICliStateStore;
+    getStateStore(name: string, defaultState?: Record<string, any>, options?: CliStateStoreOptions): ICliStateStore;
     getStoreEntries(): {
         name: string;
         state: Record<string, any>;
@@ -994,9 +1088,25 @@ declare class CliStateStoreManager implements ICliStateStoreManager {
     private readonly services;
     private readonly registry;
     private stores;
+    private channel?;
+    /** The signed-in user (for `scope: 'user'` stores). */
+    private user?;
+    private stopFollowingUser?;
     constructor(services: ICliServiceProvider, registry: ICliCommandProcessorRegistry);
-    getStateStore(name: string, defaultState?: Record<string, any>): ICliStateStore;
+    /**
+     * Get (or create) the store `name`. Defaults and options passed for a
+     * store that already exists are added to it: a store read early (e.g.
+     * by the boot report) still gets its command's initial state.
+     */
+    getStateStore(name: string, defaultState?: Record<string, any>, options?: CliStateStoreOptions): ICliStateStore;
     getProcessorStateStore(processor: ICliCommandProcessor): ICliStateStore;
+    /**
+     * Follow the signed-in user (`session:changed` events), so `scope: 'user'`
+     * stores switch to that user's state.
+     */
+    followUser(events: ICliEventBus): void;
+    /** Switch `scope: 'user'` stores to `user`'s saved state. */
+    setUser(user: string | undefined): void;
     /**
      * Returns all store names and their current state values.
      */
@@ -1004,53 +1114,14 @@ declare class CliStateStoreManager implements ICliStateStoreManager {
         name: string;
         state: Record<string, any>;
     }[];
-}
-
-type ActiveInputRequestType = 'line' | 'password' | 'confirm' | 'select' | 'select-inline' | 'multi-select' | 'number';
-interface ActiveInputRequest {
-    type: ActiveInputRequestType;
-    promptText: string;
-    resolve: (value: any) => void;
-    buffer: string;
-    cursorPosition: number;
-    defaultValue?: boolean;
-    options?: CliSelectOption[];
-    selectedIndex?: number;
-    onChange?: (value: string) => void;
-    checkedIndices?: Set<number>;
-    numberOptions?: {
-        min?: number;
-        max?: number;
-        default?: number;
-    };
-    scrollOffset?: number;
-    maxVisible?: number;
-    displayLines?: number;
-}
-interface CliInputReaderHost {
-    readonly activeInputRequest: ActiveInputRequest | null;
-    setActiveInputRequest(request: ActiveInputRequest | null): void;
-    writeToTerminal(text: string): void;
-    getTerminalRows?(): number;
-}
-declare class CliInputReader implements ICliInputReader {
-    private readonly host;
-    constructor(host: CliInputReaderHost);
-    readLine(prompt: string): Promise<string | null>;
-    readPassword(prompt: string): Promise<string | null>;
-    readConfirm(prompt: string, defaultValue?: boolean): Promise<boolean | null>;
-    readSelect(prompt: string, options: CliSelectOption[], onChange?: (value: string) => void): Promise<string | null>;
-    readSelectInline(prompt: string, options: CliSelectOption[], onChange?: (value: string) => void): Promise<string | null>;
-    readMultiSelect(prompt: string, options: CliMultiSelectOption[]): Promise<string[] | null>;
-    readNumber(prompt: string, options?: {
-        min?: number;
-        max?: number;
-        default?: number;
-    }): Promise<number | null>;
-    renderSelectOptions(options: CliSelectOption[], selectedIndex: number, scrollOffset?: number, maxVisible?: number): number;
-    renderInlineSelectOptions(options: CliSelectOption[], selectedIndex: number): string;
-    renderMultiSelectOptions(options: CliSelectOption[], selectedIndex: number, checkedIndices: Set<number>, scrollOffset?: number, maxVisible?: number): number;
-    private createInputRequest;
+    /**
+     * Dispose all stores (completes their BehaviorSubjects).
+     * Called during engine teardown.
+     */
+    dispose(): void;
+    /** Tell other tabs and terminals that a store was saved. */
+    private publish;
+    private listen;
 }
 
 /**
@@ -1086,6 +1157,10 @@ declare class CliCompletionEngine {
         candidates?: string[];
     }>;
     private buildContext;
+    /**
+     * Words with their start, quote-aware: `cat "my notes.txt"` has two, and an
+     * unclosed quote runs to the end (`cat "my no` is being typed).
+     */
     private tokenize;
     private fetchCompletions;
     /**
@@ -1099,7 +1174,7 @@ declare class CliCompletionEngine {
 /**
  * Reusable text buffer with cursor management.
  * Eliminates duplicated line-editing logic across CommandLineMode,
- * ReaderMode, and any future input mode.
+ * LineInputMode, and any future input mode.
  */
 declare class CliLineBuffer {
     private _text;
@@ -1116,6 +1191,12 @@ declare class CliLineBuffer {
     moveEnd(): void;
     clear(): void;
     setText(str: string): void;
+    /** Remove the text before the cursor (Ctrl+U); returns it */
+    deleteToStart(): string;
+    /** Remove the text from the cursor to the end (Ctrl+K); returns it */
+    deleteToEnd(): string;
+    /** Remove the whitespace-delimited word before the cursor (Ctrl+W); returns it */
+    deleteWordBefore(): string;
 }
 
 /**
@@ -1143,11 +1224,38 @@ interface IInputMode {
      * Called when this mode is no longer the active input mode.
      */
     deactivate?(): void;
+    /** Called when the terminal is resized while this mode is active. */
+    onResize?(cols: number, rows: number): void;
+}
+/**
+ * Host interface for input modes. Provides access to terminal I/O,
+ * dimensions, and mode stack management.
+ */
+interface InputModeHost {
+    /** Write raw text/ANSI to the terminal */
+    writeToTerminal(text: string): void;
+    /** Get terminal row count for scroll window sizing */
+    getTerminalRows(): number;
+    /** Get terminal column count for overflow calculations */
+    getTerminalCols(): number;
+    /** Push a mode onto the input mode stack */
+    pushMode(mode: IInputMode): void;
+    /** Pop the current mode from the input mode stack */
+    popMode(): void;
+    /** The xterm.js Terminal instance (for direct write when needed) */
+    readonly terminal: Terminal;
+    /** File picker provider for the current environment */
+    readonly filePickerProvider: ICliFilePickerProvider;
 }
 
 interface PromptOptions {
     userName?: string;
     hideUserName?: boolean;
+    /**
+     * Shown (dimmed) instead of the user name when an auth module is loaded
+     * but nobody is signed in, e.g. `anonymous:/$`. Empty/undefined: nothing.
+     */
+    anonymousName?: string;
     contextProcessor?: string;
     pathProvider?: () => string | null;
 }
@@ -1202,16 +1310,6 @@ interface CommandLineModeHost {
     }): void;
 }
 
-/**
- * Host interface for ReaderMode — provides access to the active input request.
- */
-interface ReaderModeHost {
-    readonly terminal: Terminal;
-    getActiveInputRequest(): ActiveInputRequest | null;
-    setActiveInputRequest(request: ActiveInputRequest | null): void;
-    popMode(): void;
-}
-
 interface CliExecutionContextDeps {
     services: ICliServiceProvider;
     logger: ICliLogger;
@@ -1219,10 +1317,15 @@ interface CliExecutionContextDeps {
     stateStoreManager: CliStateStoreManager;
     translator: ICliTranslationService;
 }
-declare class CliExecutionContext implements ICliExecutionContext, CliInputReaderHost, CommandLineModeHost, ReaderModeHost {
+declare class CliExecutionContext implements ICliExecutionContext, InputModeHost, CommandLineModeHost {
     terminal: Terminal;
     executor: ICliCommandExecutorService;
-    userSession?: ICliUserSession;
+    private _userSession?;
+    /** The signed-in user; changing it emits `session:changed`. */
+    get userSession(): ICliUserSession | undefined;
+    set userSession(session: ICliUserSession | undefined);
+    /** The terminal's event bus. */
+    readonly events?: ICliEventBus;
     contextProcessor?: ICliCommandProcessor;
     readonly writer: ICliTerminalWriter;
     readonly spinner: ICliSpinner;
@@ -1237,31 +1340,65 @@ declare class CliExecutionContext implements ICliExecutionContext, CliInputReade
     readonly services: ICliServiceProvider;
     readonly translator: ICliTranslationService;
     readonly backgroundServices: ICliBackgroundServiceRegistry;
+    http: ICliHttpClient;
+    readonly notifier: ICliNotifier;
     promptPathProvider?: () => string | null;
     readonly completionEngine: CliCompletionEngine;
     promptLength: number;
     readonly reader: ICliInputReader;
+    /**
+     * Result of the most recently executed command.
+     * Updated by the command executor after each command completes.
+     */
+    lastCommandResult?: {
+        command: string;
+        success: boolean;
+    };
+    /**
+     * Whether a command is currently being executed.
+     * Set by the command executor at start/end of executeCommand().
+     */
+    isExecuting: boolean;
     readonly lineBuffer: CliLineBuffer;
     readonly lineRenderer: CliTerminalLineRenderer;
     readonly commandHistory: CliCommandHistory;
-    private _activeInputRequest;
+    readonly filePickerProvider: ICliFilePickerProvider;
     private readonly modeStack;
-    private readonly managedTimers;
-    private resizeDisposable;
+    /** Command-line input typed while booting; `null` when not holding. */
+    private heldInput;
+    private releaseHeldInputAtPrompt;
+    private _typedDuringBoot;
+    private readonly stateStoreManager;
+    private readonly timerManager;
+    private readonly fullScreenManager;
+    private windowKeydownListener?;
     constructor(deps: CliExecutionContextDeps, terminal: Terminal, executor: ICliCommandExecutorService, cliOptions?: CliOptions);
-    get activeInputRequest(): ActiveInputRequest | null;
-    /**
-     * Sets the active input request. When a non-null request is provided,
-     * pushes ReaderMode onto the mode stack. ReaderMode pops itself on
-     * completion, so passing null here does NOT pop the mode.
-     */
-    setActiveInputRequest(request: ActiveInputRequest | null): void;
     writeToTerminal(text: string): void;
     getTerminalRows(): number;
+    getTerminalCols(): number;
     get currentLine(): string;
     get cursorPosition(): number;
     set cursorPosition(value: number);
     initializeTerminalListeners(): void;
+    private handleTerminalData;
+    private _isBooted;
+    /** `true` once boot has completed and the terminal is ready. */
+    get isBooted(): boolean;
+    /** Called by the engine when boot has completed. */
+    markBooted(): void;
+    /** Start keeping command-line input instead of handling it (boot). */
+    holdInput(): void;
+    /**
+     * Stop holding input: what was typed is replayed at the next prompt, or
+     * right away when `immediately` is set (e.g. no prompt will be drawn).
+     */
+    releaseInput(immediately?: boolean): void;
+    /** Whether a prompt (readLine, readSelect, ...) or full-screen mode owns the input. */
+    get isReadingInput(): boolean;
+    /** Whether keys were typed while input was held (boot). */
+    get typedDuringBoot(): boolean;
+    private replayHeldInput;
+    private initializeWindowListeners;
     setContextProcessor: (processor: ICliCommandProcessor | undefined, silent?: boolean, fullScreen?: boolean) => void;
     setCurrentLine(line: string): void;
     clearLine(): void;
@@ -1270,6 +1407,12 @@ declare class CliExecutionContext implements ICliExecutionContext, CliInputReade
         newLine?: boolean;
         keepCurrentLine?: boolean;
     }): void;
+    /**
+     * Submit and execute a command — shared by interactive Enter key
+     * and programmatic engine.execute(). Adds to history, runs the
+     * command, and shows a new prompt afterwards.
+     */
+    submitCommand(command: string): Promise<void>;
     clearCurrentLine(): void;
     refreshCurrentLine(previousContentLength?: number): void;
     /**
@@ -1285,7 +1428,7 @@ declare class CliExecutionContext implements ICliExecutionContext, CliInputReade
      */
     handleTerminalResize(): void;
     isRawModeActive(): boolean;
-    enterFullScreenMode(processor: ICliCommandProcessor): void;
+    enterFullScreenMode(processor: ICliCommandProcessor, options?: CliFullScreenOptions): void;
     exitFullScreenMode(): void;
     createInterval(callback: () => void, ms: number): ICliManagedInterval;
     createTimeout(callback: () => void, ms: number): ICliManagedTimer;
@@ -1296,8 +1439,6 @@ declare class CliExecutionContext implements ICliExecutionContext, CliInputReade
     getPromptLength(): number;
     setPromptLength(value: number): void;
     getExecutionContext(): ICliExecutionContext;
-    getActiveInputRequest(): ActiveInputRequest | null;
-    private clearAllManagedTimers;
     /**
      * Dispose all resources. Called by CliEngine.destroy() when the
      * CLI component is being torn down.
@@ -1308,6 +1449,100 @@ declare class CliExecutionContext implements ICliExecutionContext, CliInputReade
     popMode(): void;
 }
 
+/**
+ * Per-session registry that manages background service lifecycle.
+ */
+declare class CliBackgroundServiceRegistry implements ICliBackgroundServiceRegistry {
+    private readonly state;
+    private readonly services;
+    private readonly writer?;
+    private readonly entries;
+    private readonly handlers;
+    private isFullScreen;
+    private notificationQueue;
+    private processRegistry?;
+    constructor(state: ICliStateStore, services: ICliServiceProvider, writer?: ICliTerminalWriter);
+    /** Attach the process registry so background services get PIDs */
+    setProcessRegistry(registry: ICliProcessRegistry): void;
+    register(service: ICliBackgroundService): void;
+    start(name: string): Promise<void>;
+    stop(name: string): Promise<void>;
+    restart(name: string): Promise<void>;
+    startJob(name: string, task: (context: ICliServiceContext) => Promise<void>, _options?: {
+        workerCompatible?: boolean;
+    }): Promise<void>;
+    getStatus(name: string): ICliBackgroundServiceInfo | undefined;
+    list(): ICliBackgroundServiceInfo[];
+    getLogs(name: string, limit?: number): ICliServiceLogEntry[];
+    on(handler: CliServiceEventHandler, filter?: {
+        source?: string;
+        type?: string;
+    }): () => void;
+    destroyAll(): Promise<void>;
+    /** Called by the execution context when entering/exiting full-screen mode */
+    setFullScreen(isFullScreen: boolean): void;
+    private getEntry;
+    private toInfo;
+    private updateStatus;
+    private handleStartError;
+    private dispatchEvent;
+    /**
+     * Publish service events on the terminal's event bus: lifecycle events as
+     * `service:<started|stopped|...>`, events relayed from a server's event
+     * socket as `server:event`, other custom events as `service:event`.
+     */
+    private forwardToEventBus;
+    private emitLifecycleEvent;
+    private notify;
+    private flushNotificationQueue;
+    private writeNotification;
+    private completeInProcessRegistry;
+    private failInProcessRegistry;
+}
+
+/**
+ * Manages full-screen terminal mode (alternate screen buffer).
+ * Used by interactive commands like nano, htop, etc.
+ */
+declare class CliFullScreenManager {
+    private readonly terminal;
+    private readonly backgroundServices;
+    private resizeDisposable;
+    constructor(terminal: Terminal, backgroundServices: CliBackgroundServiceRegistry);
+    /**
+     * Enter full-screen mode using the alternate screen buffer.
+     */
+    enter(processor: ICliCommandProcessor, setContextProcessor: (p: ICliCommandProcessor | undefined, silent?: boolean, fullScreen?: boolean) => void, context: ICliExecutionContext, options?: CliFullScreenOptions): void;
+    /**
+     * Exit full-screen mode and return to the main buffer.
+     */
+    exit(contextProcessor: ICliCommandProcessor | undefined, setContextProcessor: (p: ICliCommandProcessor | undefined) => void, clearTimers: () => void, showPrompt: () => void, context: ICliExecutionContext): void;
+    /**
+     * Dispose resize subscription.
+     */
+    dispose(): void;
+}
+
+/**
+ * Manages timers and intervals with automatic cleanup.
+ * All managed timers are cleared when the execution context is disposed.
+ */
+declare class CliTimerManager {
+    private readonly managedTimers;
+    /**
+     * Create a managed interval that will be automatically cleared on dispose.
+     */
+    createInterval(callback: () => void, ms: number): ICliManagedInterval;
+    /**
+     * Create a managed timeout that will be automatically cleared on dispose.
+     */
+    createTimeout(callback: () => void, ms: number): ICliManagedTimer;
+    /**
+     * Clear all managed timers and intervals.
+     */
+    clearAll(): void;
+}
+
 /**
  * Extended execution context interface used internally by the command executor.
  * The concrete implementation (e.g. CliExecutionContext in angular-cli) provides these.
@@ -1315,34 +1550,37 @@ declare class CliExecutionContext implements ICliExecutionContext, CliInputReade
 interface ICliExecutionHost extends ICliExecutionContext {
     contextProcessor?: ICliCommandProcessor;
     abort?(): void;
+    lastCommandResult?: {
+        command: string;
+        success: boolean;
+    };
+    isExecuting?: boolean;
 }
 declare class CliCommandExecutor implements ICliCommandExecutorService {
     protected readonly registry: ICliCommandProcessorRegistry;
     private commandParser;
     private globalParameters;
-    private lastCapturingWriter?;
+    /** Exit status of the last command, expanded as `$?` (0 = success). */
+    private lastExitCode;
+    /** Command lines running per terminal (they can overlap). */
+    private readonly running;
+    /** Exit status of the last command line run (`$?`). */
+    get exitStatus(): number;
     constructor(registry: ICliCommandProcessorRegistry);
     registerGlobalParameter(handler: ICliGlobalParameterHandler): void;
-    getGlobalParameters(): ICliCommandParameterDescriptor[];
+    getGlobalParameters(): ICliCommandParameterDescriptor$1[];
     executeCommand(command: string, context: ICliExecutionContext): Promise<void>;
-    private appendOutputToFile;
-    private writeOutputToFile;
-    private executeSingleCommand;
-    private writeStderrToFile;
-    private appendStderrToFile;
-    showHelp(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    /** Whether the command named first on the line takes literal input. */
+    private isLiteralInput;
     /**
-     * Attempt to execute a file path as a script.
-     * Returns true if the file was found and executed, false otherwise.
-     * Requires the @qodalis/cli-files plugin for filesystem access.
+     * Run a command line and return its output as text instead of showing
+     * it (`$(...)`); its errors and warnings are still shown.
      */
-    private tryExecuteScript;
-    private substituteVars;
-    /**
-     * Expand $VAR and ${VAR} references using the global environment store.
-     * Variables inside single-quoted strings are NOT expanded (like bash).
-     */
-    private expandEnvironmentVars;
+    capture(command: string, from: ICliExecutionContext): Promise<string>;
+    private executeSingleCommand;
+    private completeProcess;
+    private failProcess;
+    showHelp(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
     /**
      * Validates the command arguments before execution.
      * @param context The current CLI execution context.
@@ -1360,6 +1598,19 @@ declare class CliCommandExecutor implements ICliCommandExecutorService {
      * parameter.  In that case the global handler must be skipped so the
      * processor can handle the flag itself.
      */
+    /**
+     * Runs all registered {@link ICliCommandGuard}s that apply to this command,
+     * in priority order. Returns the block message of the first guard that
+     * denies the command, or `undefined` when every guard allows it.
+     * A guard that throws is treated as a denial (fail closed).
+     */
+    private runGuards;
+    /**
+     * The text after the word that selected `processor`, which may be its
+     * command or one of its aliases (e.g. `pkg rm guid` -> `guid`).
+     */
+    private extractPositionalValue;
+    private guardDenial;
     private processorOwnsParameter;
 }
 
@@ -1377,57 +1628,395 @@ declare const helpGlobalParameter: ICliGlobalParameterHandler;
 declare const contextGlobalParameter: ICliGlobalParameterHandler;
 
 /**
- * A simple Map-based service container implementing ICliServiceProvider.
+ * A terminal writer wrapper that captures "stdout-equivalent" output
+ * (`write`, `writeln`, `writeJson`, `writeObjectsAsTable`, `writeTable`)
+ * while passing everything through to the underlying writer unchanged.
  *
- * Supports three provider types:
- * - `useValue`   : registers a static value
- * - `useFactory` : registers a factory function, invoked once on first `get`
- * - `useClass`   : registers a class constructor, instantiated once on first `get`
+ * Diagnostic methods (`writeError`, `writeWarning`, `writeInfo`, `writeSuccess`)
+ * are NOT captured — they are the equivalent of stderr.
  *
- * When `multi: true`, multiple providers for the same token are accumulated
- * and `get()` returns an array of resolved values.
+ * After a command finishes, the executor can retrieve the captured data to use
+ * as implicit pipeline output when the command did not call `process.output()`.
+ *
+ * `muted` (output going into a pipe or a file) captures stdout-equivalent
+ * output without showing it; diagnostics are still shown.
  */
-declare class CliServiceContainer implements ICliServiceProvider {
-    /** Stores single-value providers (resolved or pending). */
-    private readonly services;
-    /** Stores multi-provider arrays. */
-    private readonly multiServices;
-    /**
-     * Retrieve a service by its token.
-     *
-     * @param token The token used to register the service.
-     * @returns The resolved service instance (or array for multi providers).
-     * @throws Error if the token has not been registered.
-     */
-    get<T>(token: any): T;
-    /**
-     * Register one or more providers.
-     *
-     * @param definition A single CliProvider or an array of CliProviders.
-     */
-    set(definition: CliProvider | CliProvider[]): void;
-    /**
+declare class CapturingTerminalWriter implements ICliTerminalWriter {
+    private readonly inner;
+    /** Raw text lines captured from write/writeln calls. */
+    private _lines;
+    /** Structured data captured from writeJson calls. */
+    private _jsonValues;
+    /** Structured data captured from writeObjectsAsTable calls. */
+    private _tableObjects;
+    /** Raw text lines captured from writeError/writeWarning calls. */
+    private _stderrLines;
+    /** Number of writeError calls (warnings excluded). */
+    private _errorCount;
+    private readonly muted;
+    constructor(inner: ICliTerminalWriter, options?: {
+        muted?: boolean;
+    });
+    /** Show stdout-equivalent output unless muted. */
+    private show;
+    private captureText;
+    write(text: string): void;
+    writeln(text?: string): void;
+    writeJson(json: any): void;
+    writeObjectsAsTable(objects: any[]): void;
+    writeTable(headers: string[], rows: string[][]): void;
+    writeSuccess(message: string): void;
+    writeInfo(message: string): void;
+    writeWarning(message: string): void;
+    writeError(message: string): void;
+    wrapInColor(text: string, color: CliForegroundColor): string;
+    wrapInBackgroundColor(text: string, color: CliBackgroundColor): string;
+    writeToFile(fileName: string, content: string): void;
+    writeDivider(options?: {
+        color?: CliForegroundColor;
+        length?: number;
+        char?: string;
+    }): void;
+    writeList(items: string[], options?: {
+        ordered?: boolean;
+        prefix?: string;
+        color?: CliForegroundColor;
+    }): void;
+    writeKeyValue(entries: Record<string, string> | [string, string][], options?: {
+        separator?: string;
+        keyColor?: CliForegroundColor;
+    }): void;
+    writeColumns(items: string[], options?: {
+        columns?: number;
+        padding?: number;
+    }): void;
+    writeLink(text: string, url: string): void;
+    writeBox(content: string | string[], options?: {
+        title?: string;
+        borderColor?: CliForegroundColor;
+        padding?: number;
+    }): void;
+    writeIndented(text: string, level?: number): void;
+    /**
+     * Returns true if any stdout-equivalent output was captured.
+     */
+    hasOutput(): boolean;
+    /**
+     * Returns the captured data in the most useful form:
+     *
+     * 1. If structured JSON was written (via `writeJson`), return the last
+     *    JSON value (preserving its original type — object, array, etc.).
+     * 2. If objects were written as a table, return the last array of objects.
+     * 3. Otherwise return the captured text lines joined with newlines,
+     *    with ANSI codes stripped and whitespace trimmed.
+     * 4. Returns `undefined` if nothing was captured.
+     */
+    getCapturedData(): any | undefined;
+    /** Whether the command wrote an error message itself. */
+    hasErrors(): boolean;
+    /**
+     * Returns true if any stderr-equivalent output was captured.
+     */
+    hasStderr(): boolean;
+    /**
+     * Returns captured stderr text joined with newlines, or undefined if empty.
+     */
+    getCapturedStderr(): string | undefined;
+}
+
+/**
+ * Write stdout data to a file (overwrite mode).
+ */
+declare function writeOutputToFile(filePath: string, context: ICliExecutionContext): Promise<void>;
+/**
+ * Append stdout data to a file.
+ */
+declare function appendOutputToFile(filePath: string, context: ICliExecutionContext): Promise<void>;
+/**
+ * Write stderr data to a file (overwrite mode).
+ */
+declare function writeStderrToFile(filePath: string, context: ICliExecutionContext, capturingWriter?: CapturingTerminalWriter): Promise<void>;
+/**
+ * Append stderr data to a file.
+ */
+declare function appendStderrToFile(filePath: string, context: ICliExecutionContext, capturingWriter?: CapturingTerminalWriter): Promise<void>;
+
+/**
+ * Attempt to execute a file path as a script.
+ * Returns true if the file was found and executed, false otherwise.
+ * Requires the @qodalis/cli-files plugin for filesystem access.
+ */
+declare function tryExecuteScript(filePath: string, context: ICliExecutionHost, executeCommand: (command: string, context: ICliExecutionContext) => Promise<void>): Promise<boolean>;
+/**
+ * Substitute script-local variables ($VAR / ${VAR}) in a string.
+ */
+declare function substituteVars(input: string, variables: Record<string, string>): string;
+/**
+ * Expand `$VAR` and `${VAR}` references using the global environment store, `$?`
+ * to the last exit status, and a leading `~` (alone or as `~/…`) to `$HOME`.
+ * Nothing is expanded inside single-quoted strings (like bash).
+ */
+declare function expandEnvironmentVars(command: string, context: ICliExecutionContext, lastExitCode?: number): string;
+
+/**
+ * Shell-style script runner shared by `sh <file>` / `source` (files plugin)
+ * and `./script.sh` (the executor).
+ *
+ * Supported (a POSIX sh subset):
+ *   - one command per line or several separated by `;` (pipes, `&&`, `||`
+ *     and redirects are left to the executor)
+ *   - `# comments`, blank lines, `\` line continuation
+ *   - `set -e` (default) / `set +e`, `VAR=value` (script-scoped), `exit [n]`
+ *   - `if cmd; then ...; elif cmd; then ...; else ...; fi`
+ *   - `for NAME in words...; do ...; done` (words after `$VAR` and wildcard
+ *     expansion; NAME is set for this terminal)
+ *   - `while cmd; do ...; done`, `until cmd; do ...; done`
+ *   - `break [n]`, `continue [n]`, `! cmd` (negated status)
+ *
+ * Every simple command runs through the executor; its status is
+ * `context.process.exitCode` (0 or undefined = success).
+ */
+/** Service token under which the engine provides the runner (for plugins). */
+declare const ICliScriptRunner_TOKEN: any;
+interface ICliScriptRunOptions {
+    /** Prefix for error messages (`sh: line 4: ...`). Default `sh`. */
+    name?: string;
+    /** Runs one command line. Default `context.executor.executeCommand`. */
+    executeCommand?: (command: string, context: ICliExecutionContext) => Promise<void>;
+    /** Loop iterations allowed before a `while`/`until` is stopped. Default 10000. */
+    maxLoopIterations?: number;
+    /** Stop at the first failing command (`set -e`). Default true; false for typed lines. */
+    stopOnError?: boolean;
+}
+interface ICliScriptRunner {
+    /** Run script `content`; resolves to its exit status. */
+    run(content: string, context: ICliExecutionContext, options?: ICliScriptRunOptions): Promise<number>;
+}
+/** The runner as a service value. */
+declare const cliScriptRunner: ICliScriptRunner;
+interface CommandNode {
+    type: 'command';
+    text: string;
+    line: number;
+    negate: boolean;
+}
+interface IfNode {
+    type: 'if';
+    line: number;
+    branches: {
+        condition: ScriptNode[];
+        body: ScriptNode[];
+    }[];
+    elseBody?: ScriptNode[];
+}
+interface ForNode {
+    type: 'for';
+    line: number;
+    name: string;
+    words: string;
+    body: ScriptNode[];
+}
+interface WhileNode {
+    type: 'while';
+    line: number;
+    until: boolean;
+    condition: ScriptNode[];
+    body: ScriptNode[];
+}
+type ScriptNode = CommandNode | IfNode | ForNode | WhileNode;
+/** A syntax error found while parsing. */
+declare class CliScriptSyntaxError extends Error {
+    readonly line: number;
+    readonly detail: string;
+    constructor(line: number, detail: string);
+}
+/** Parse script content (throws {@link CliScriptSyntaxError}). */
+declare function parseScript(content: string): ScriptNode[];
+/** Split a line into words, removing quotes (empty quoted words are kept). */
+declare function splitWords(text: string): string[];
+/**
+ * Run script content with shell control flow. Resolves to the exit status
+ * (also set as the context's process exit code).
+ */
+declare function runScript(content: string, context: ICliExecutionContext, options?: ICliScriptRunOptions): Promise<number>;
+
+/** The file system calls glob expansion needs (`@qodalis/cli-files`). */
+interface GlobFileSystem {
+    getCurrentDirectory(): string;
+    resolvePath(path: string): string;
+    listDirectory(path: string): {
+        name: string;
+        type: 'file' | 'directory';
+    }[];
+    exists(path: string): boolean;
+    isDirectory(path: string): boolean;
+}
+/**
+ * Expand `*`, `?` and `[...]` in unquoted arguments to the matching paths,
+ * as a shell does: `rm *.txt`, `cat docs/*.md`. The command name and flags
+ * are left alone, names starting with `.` match only a pattern that starts
+ * with `.`, and a pattern that matches nothing is kept as typed.
+ * Without the files plugin the command is returned unchanged.
+ */
+declare function expandGlobs(command: string, context: ICliExecutionContext): string;
+/** Paths matching `pattern`, sorted, relative when the pattern is. */
+declare function matchGlob(fs: GlobFileSystem, pattern: string): string[];
+/**
+ * Brace expansion, as a shell does before wildcards: `file.{ts,js}` is
+ * `file.ts file.js`, `img{1..3}.png` is `img1.png img2.png img3.png`
+ * (letters too: `{a..c}`). Only unquoted words with a `,` or `..` inside
+ * balanced braces; `${VAR}` and quoted text are left alone. Works without
+ * the files plugin.
+ */
+declare function expandBraces(command: string): string;
+
+/**
+ * Replace `$(command)` and `` `command` `` with the command's output, as a
+ * shell does: `echo "Today: $(date)"`. Not inside single quotes; inside
+ * double quotes yes. Trailing newlines of the output are removed, and the
+ * output is escaped so it is only ever text: inside double quotes `"`, `\`,
+ * `$` and `` ` ``; outside quotes every shell character but spaces (which
+ * still separate words), so quotes, operators, `$`, wildcards and braces in
+ * the output are not interpreted.
+ */
+declare function substituteCommands(command: string, run: (inner: string) => Promise<string>): Promise<string>;
+
+/**
+ * A simple Map-based service container implementing ICliServiceProvider.
+ *
+ * Supports three provider types:
+ * - `useValue`   : registers a static value
+ * - `useFactory` : registers a factory function, invoked once on the first `get`
+ * - `useClass`   : registers a class constructor, instantiated once on the first `get`
+ *
+ * Factories and classes are created lazily, so their `deps` only have to be
+ * registered by the time the service is first used. Add `transient: true` to
+ * create a new instance on every `get`.
+ *
+ * When `multi: true`, multiple providers for the same token are accumulated
+ * and `getAll()` returns all of them.
+ *
+ * Registering a single token again overrides it; removing that registration
+ * (`remove(token, provider)`, e.g. when a module is unloaded) makes the
+ * previous one active again.
+ */
+declare class CliServiceContainer implements ICliServiceProvider {
+    /** Single-value registrations; the last one is active. */
+    private readonly services;
+    /** Multi-provider registrations, in registration order. */
+    private readonly multiServices;
+    /** Tokens that cannot be overwritten by subsequent `set()` calls. */
+    private readonly sealedTokens;
+    /** Stores provider recipes for transient tokens (re-resolved on every get). */
+    private readonly transientRecipes;
+    private disposed;
+    /** Registrations being created, to report dependency cycles. */
+    private readonly resolving;
+    /**
+     * Retrieve a service by its token.
+     * Returns `undefined` when no provider is registered for the token.
+     * For multi-provider tokens, returns the last registered value (use `getAll` for the full array).
+     *
+     * @param token The token used to register the service.
+     * @returns The resolved service instance, or `undefined` if not registered.
+     */
+    get<T>(token: CliToken<T>): T | undefined;
+    get<T>(token: any): T | undefined;
+    /**
+     * Retrieve all registered services for a multi-provider token.
+     * Returns an empty array when no provider is registered for the token.
+     *
+     * @param token The token used to register the service.
+     * @returns Array of all resolved service instances.
+     */
+    getAll<T>(token: CliToken<T>): T[];
+    getAll<T>(token: any): T[];
+    /**
+     * Retrieve a service by its token, throwing if not registered.
+     * Use this when the service is required and its absence is a programming error.
+     * For multi-provider tokens, returns the last registered value (use `getAll` for the full array).
+     *
+     * @param token The token used to register the service.
+     * @returns The resolved service instance.
+     * @throws Error if the token has not been registered.
+     */
+    getRequired<T>(token: CliToken<T>): T;
+    getRequired<T>(token: any): T;
+    /**
+     * Check whether a service is registered for the given token.
+     */
+    has(token: any): boolean;
+    /**
+     * Mark a token as sealed so it cannot be overwritten by future `set()` calls.
+     * Only available on the concrete container — not exposed on `ICliServiceProvider`.
+     */
+    seal(token: any): void;
+    /**
+     * Mark multiple tokens as sealed at once.
+     */
+    sealAll(tokens: any[]): void;
+    /**
+     * Check whether a token is sealed.
+     */
+    isSealed(token: any): boolean;
+    /**
+     * Register one or more providers.
+     *
+     * @param definition A single CliProvider or an array of CliProviders.
+     */
+    set(definition: CliProvider | CliProvider[]): void;
+    /**
+     * Remove a registration. With `provider` (the provider object passed to
+     * `set`, or the registered value), only that registration is removed: for
+     * a single token the previous registration becomes active again, for a
+     * multi token the others remain. Without it, every registration of the
+     * token is removed.
+     *
+     * @throws Error if the token is sealed.
+     * @returns Whether something was removed.
+     */
+    remove(token: any, provider?: unknown): boolean;
+    /**
+     * Dispose the services the container created (`useFactory` / `useClass`)
+     * that have a `dispose()` method. Values registered with `useValue`
+     * belong to whoever registered them and are not disposed. Registrations
+     * are kept, so late callbacks still find their services. Called when the
+     * engine is destroyed; later calls do nothing.
+     */
+    dispose(): void;
+    /**
      * Returns all registered service tokens (single + multi providers).
      */
     getRegisteredTokens(): string[];
     /**
      * Returns detailed info for each registered service: token name, value type, and multi flag.
+     * Services not created yet are listed as `lazy(Name)` (listing does not create them).
      */
     getRegisteredServiceDetails(): {
         token: string;
         type: string;
         multi: boolean;
     }[];
+    /**
+     * Convert a token to a human-readable string for diagnostics/errors.
+     */
+    private tokenToString;
+    private describeRegistration;
     /**
      * Describe a resolved value for diagnostic display.
      */
     private describeValue;
+    /** Whether `registration` is the one `provider` refers to. */
+    private matches;
     /**
      * Register a single provider.
      */
     private registerProvider;
+    /** The value of a registration, created on first use. */
+    private resolve;
     /**
-     * Resolve a provider definition to a concrete value.
+     * Resolve a provider definition to a concrete value, resolving its `deps`
+     * from the container.
      */
     private resolveProvider;
 }
@@ -1465,7 +2054,16 @@ declare class CliTerminalWriter implements ICliTerminalWriter {
         columns?: number;
         padding?: number;
     }): void;
-    writeTable(headers: string[], rows: string[][]): void;
+    writeLink(text: string, url: string): void;
+    writeBox(content: string | string[], options?: {
+        title?: string;
+        borderColor?: CliForegroundColor;
+        padding?: number;
+    }): void;
+    writeIndented(text: string, level?: number): void;
+    /** One block per row, header names as keys; used when a table cannot fit the terminal. */
+    private writeRecords;
+    writeTable(headers: string[], rows: string[][], options?: CliTableOptions): void;
 }
 
 declare class CliClipboard implements ICliClipboard {
@@ -1528,11 +2126,6 @@ declare class CliTerminalProgressBar implements ICliPercentageProgressBar {
     complete(): void;
     setText(text: string): void;
     private updateProgressBar;
-    /**
-     * Returns an ANSI 256-color escape for a position in the progress bar.
-     * Gradient: red (0%) -> yellow (50%) -> green (100%).
-     */
-    private progressGradientColor;
     private clearCurrentLine;
     private calcLineCount;
 }
@@ -1542,11 +2135,22 @@ declare class CliTerminalTextAnimator implements ICliTextAnimator {
     isRunning: boolean;
     context?: ICliExecutionContext;
     private animationInterval?;
+    /** Characters of the current animation still visible on the line. */
+    private visibleChars;
+    /** Ends the current `showText` promise early (set while it runs). */
+    private finish?;
     private text;
     private textColor;
     constructor(terminal: Terminal);
     show(text?: string): void;
     showText(text: string, options?: CliTextAnimatorOptions): Promise<void>;
+    /** Cursor position as `row:col`, or `null` when unavailable. */
+    private cursorPosition;
+    /**
+     * Stop the animation, erase the text it wrote and resolve its `showText`
+     * promise. Used when the user starts typing over the greeting.
+     */
+    cancel(): void;
     /**
      * Hide the animation and reset the state.
      */
@@ -1563,6 +2167,101 @@ interface ICliWelcomeModule extends ICliModule {
     configure(config: CliWelcomeMessageConfig): ICliModule;
 }
 declare const welcomeModule: ICliWelcomeModule;
+/**
+ * Animated, time-based greeting on the first prompt. Runs after every other
+ * module's `onAfterBoot` hook (setup and sign-in prompts come first), and
+ * only when the welcome banner was shown.
+ */
+declare const greetingModule: ICliModule;
+
+interface CliBootLogOptions {
+    /** Steps taking at least this long are highlighted as slow. */
+    slowStepMs?: number;
+    /** When boot started (ms since epoch); defaults to now. */
+    startedAt?: number;
+}
+/**
+ * Live boot report written to the terminal while the CLI starts: a list of
+ * the steps (terminal, services, servers, modules) with a thin progress bar
+ * and percentage pinned below it.
+ *
+ * Anything else written to the terminal meanwhile is captured and the bar
+ * steps aside for it. When boot is complete the report is cleared so the
+ * regular terminal takes over; warnings, errors and other output (plugin
+ * warnings) are written again in order. First-run setup prompts, answered
+ * while the report is suspended, are cleared with it.
+ *
+ * A disabled log records problems but writes nothing.
+ */
+declare class CliBootLog {
+    private readonly terminal;
+    readonly enabled: boolean;
+    private readonly startedAt;
+    private readonly slowStepMs;
+    private readonly problems;
+    private finished;
+    private totalSteps;
+    private completedSteps;
+    private current;
+    private barVisible;
+    private cursorHidden;
+    private suspended;
+    private startRow;
+    /** Output written by others during boot, replayed after the report is cleared. */
+    private readonly captured;
+    private originalWrite?;
+    private originalWriteln?;
+    private redrawScheduled;
+    /** The last setup output did not end its line (cursor after a prompt). */
+    private promptOpen;
+    constructor(terminal: Terminal | undefined, enabled: boolean, options?: CliBootLogOptions);
+    /** Milliseconds since boot started. */
+    get elapsedMs(): number;
+    /** Whether `finish()` was called; later entries are ignored. */
+    get isFinished(): boolean;
+    /** Completed share of the planned steps, 0–100. */
+    get percent(): number;
+    /** Announce `count` more steps that will each be completed with `completeStep`. */
+    addSteps(count: number): void;
+    /** Name what is being set up now (shown next to the bar). */
+    setCurrent(text: string): void;
+    /** Mark one planned step as done (successfully or not). */
+    completeStep(): void;
+    /**
+     * Step aside for interactive output (e.g. a module's first-run setup
+     * prompt): remove the bar and show the cursor until `resume()`.
+     */
+    suspend(): void;
+    /** Bring the bar back after `suspend()`. */
+    resume(): void;
+    info(text: string): void;
+    /** A completed step, optionally with how long it took. */
+    ok(text: string, durationMs?: number): void;
+    warn(text: string): void;
+    error(text: string): void;
+    /**
+     * Write the summary line, then hand the screen over to the terminal:
+     * clear the report (unless `keep`), then write warnings, errors and the
+     * output captured during boot again. The report is not cleared when the
+     * terminal already held something before boot started.
+     */
+    finish(summary: string, keep?: boolean): Promise<void>;
+    private write;
+    /** Redraw the bar on the line below the list (the cursor stays on it). */
+    private drawBar;
+    /** First output: remember where the report starts and capture other writes. */
+    private begin;
+    private stopCapture;
+    /** Someone else writes during boot: move the bar aside and keep a copy. */
+    private onExternalWrite;
+    /** Write without being captured. */
+    private out;
+    private hideBar;
+    private format;
+    private absoluteRow;
+    /** Resolve once xterm has parsed everything written so far. */
+    private flush;
+}
 
 declare class CliBoot {
     private readonly registry;
@@ -1571,13 +2270,61 @@ declare class CliBoot {
     private initializing;
     private readonly moduleRegistry;
     private readonly bootedModules;
+    private readonly initializedProcessors;
+    /** Services and guards each module registered, removed when it is unloaded. */
+    private readonly moduleProviders;
+    /** Context modules were booted with (passed to `onDestroy` on unload). */
+    private context?;
+    /** Boot report of the startup boot. */
+    private bootLogRef?;
+    /** The boot report while startup is still in progress, else `undefined`. */
+    private get bootLog();
     constructor(registry: ICliCommandProcessorRegistry, services: ICliServiceProvider);
     /**
      * Get the module registry for external access.
      */
     getModuleRegistry(): CliModuleRegistry;
-    boot(context: CliExecutionContext, modules: ICliModule[]): Promise<void>;
+    boot(context: CliExecutionContext, modules: ICliModule[], bootLog?: CliBootLog): Promise<void>;
+    private bootAll;
+    /**
+     * Boot one module: declarations (services, guards, permissions,
+     * translations), lifecycle (`onInit`, first-run `onSetup`), then its
+     * commands. Modules already booted or with missing dependencies are skipped.
+     */
     private bootModule;
+    private dependenciesLoaded;
+    /** Services, guards, permissions and translations the module declares. */
+    private registerDeclarations;
+    /** `onInit` runs before the module's commands are registered. */
+    private runOnInit;
+    /** `onSetup` runs once per browser (first-run flow), until it succeeds. */
+    private runFirstSetup;
+    /** Register and initialize the module's commands; returns how many. */
+    private registerCommands;
+    /** One boot-log line per module that does something at boot. */
+    private reportModule;
+    /**
+     * Unload a module (`pkg remove`, or before `pkg update` boots the new
+     * version): its commands, guards and permissions are removed at once,
+     * then `onDestroy` runs, then its services are removed (so `onDestroy`
+     * can still use them). Services are removed by registration, so a newer
+     * version registered meanwhile keeps its own.
+     */
+    private unloadModule;
+    private removeProviders;
+    /** Publish on the event bus; never lets the bus break booting. */
+    private emitEvent;
+    /** Boot warning: into the boot log when it is shown, else the terminal. */
+    private warn;
+    /** Boot error: into the boot log when it is shown, else the terminal. */
+    private fail;
+    /**
+     * Sub-processors of an `extendsProcessor` processor are merged into the
+     * processor it extends, so they belong to that one: re-parent them so they
+     * inherit its access rules (`requiredPermissions` etc.) and help/root
+     * lookups resolve to the registered processor.
+     */
+    private adoptMergedSubProcessors;
     private buildCoreModule;
     /**
      * Topologically sort modules by their dependencies using DFS.
@@ -1641,6 +2388,13 @@ declare class ScriptLoaderService {
         content?: string;
         error?: any;
     }>;
+    /**
+     * Inject an inline script into the page.
+     *
+     * **Security:** This runs `code` in the host page context with full
+     * DOM access. Only call with trusted content (e.g. verified UMD bundles
+     * loaded via the package manager). Never pass user-supplied strings.
+     */
     injectBodyScript(code: string): void;
     /**
      * Returns CDN URLs for a given npm package path.
@@ -1671,14 +2425,18 @@ declare class CliPackageManagerService {
     private readonly storageKey;
     QODALIS_COMMAND_PREFIX: string;
     private store;
+    /** In-memory cache; `null` means "not yet loaded from storage". */
+    private cache;
+    /** Whether the one-time localStorage migration has been checked. */
+    private migrationDone;
     constructor();
     /**
      * Set the key-value store instance for persistence.
      */
     setStore(store: ICliKeyValueStore): void;
     /**
-     * Retrieves the list of packages
-     * @returns {Package[]} Array of packages
+     * Retrieves the list of packages.
+     * Uses an in-memory cache after the first load.
      */
     getPackages(): Promise<Package[]>;
     /**
@@ -1709,90 +2467,31 @@ declare class CliDefaultPingServerService implements ICliPingServerService {
 }
 
 /**
- * A terminal writer wrapper that captures "stdout-equivalent" output
- * (`write`, `writeln`, `writeJson`, `writeObjectsAsTable`, `writeTable`)
- * while passing everything through to the underlying writer unchanged.
- *
- * Diagnostic methods (`writeError`, `writeWarning`, `writeInfo`, `writeSuccess`)
- * are NOT captured — they are the equivalent of stderr.
- *
- * After a command finishes, the executor can retrieve the captured data to use
- * as implicit pipeline output when the command did not call `process.output()`.
+ * Factory-based input reader. Creates the appropriate input mode
+ * and pushes it onto the mode stack for each request.
  */
-declare class CapturingTerminalWriter implements ICliTerminalWriter {
-    private readonly inner;
-    /** Raw text lines captured from write/writeln calls. */
-    private _lines;
-    /** Structured data captured from writeJson calls. */
-    private _jsonValues;
-    /** Structured data captured from writeObjectsAsTable calls. */
-    private _tableObjects;
-    /** Raw text lines captured from writeError/writeWarning calls. */
-    private _stderrLines;
-    constructor(inner: ICliTerminalWriter);
-    write(text: string): void;
-    writeln(text?: string): void;
-    writeJson(json: any): void;
-    writeObjectsAsTable(objects: any[]): void;
-    writeTable(headers: string[], rows: string[][]): void;
-    writeSuccess(message: string): void;
-    writeInfo(message: string): void;
-    writeWarning(message: string): void;
-    writeError(message: string): void;
-    wrapInColor(text: string, color: CliForegroundColor): string;
-    wrapInBackgroundColor(text: string, color: CliBackgroundColor): string;
-    writeToFile(fileName: string, content: string): void;
-    writeDivider(options?: {
-        color?: CliForegroundColor;
-        length?: number;
-        char?: string;
-    }): void;
-    writeList(items: string[], options?: {
-        ordered?: boolean;
-        prefix?: string;
-        color?: CliForegroundColor;
-    }): void;
-    writeKeyValue(entries: Record<string, string> | [string, string][], options?: {
-        separator?: string;
-        keyColor?: CliForegroundColor;
-    }): void;
-    writeColumns(items: string[], options?: {
-        columns?: number;
-        padding?: number;
-    }): void;
-    /**
-     * Returns true if any stdout-equivalent output was captured.
-     */
-    hasOutput(): boolean;
-    /**
-     * Returns the captured data in the most useful form:
-     *
-     * 1. If structured JSON was written (via `writeJson`), return the last
-     *    JSON value (preserving its original type — object, array, etc.).
-     * 2. If objects were written as a table, return the last array of objects.
-     * 3. Otherwise return the captured text lines joined with newlines,
-     *    with ANSI codes stripped and whitespace trimmed.
-     * 4. Returns `undefined` if nothing was captured.
-     */
-    getCapturedData(): any | undefined;
-    /**
-     * Returns true if any stderr-equivalent output was captured.
-     */
-    hasStderr(): boolean;
-    /**
-     * Returns captured stderr text joined with newlines, or undefined if empty.
-     */
-    getCapturedStderr(): string | undefined;
+declare class CliInputReader implements ICliInputReader {
+    private readonly host;
+    constructor(host: InputModeHost);
+    readLine(prompt: string, options?: CliLineOptions): Promise<string | null>;
+    readPassword(prompt: string): Promise<string | null>;
+    readConfirm(prompt: string, defaultValue?: boolean): Promise<boolean | null>;
+    readSelect(prompt: string, options: CliSelectOption[], selectOptions?: CliSelectOptions): Promise<string | null>;
+    readSelectInline(prompt: string, options: CliSelectOption[], selectOptions?: CliSelectOptions): Promise<string | null>;
+    readMultiSelect(prompt: string, options: CliMultiSelectOption[], selectOptions?: CliMultiSelectOptions): Promise<string[] | null>;
+    readNumber(prompt: string, options?: CliNumberOptions): Promise<number | null>;
+    readDate(prompt: string, options?: CliDateOptions): Promise<string | null>;
+    readFile(prompt: string, options?: CliFilePickerOptions): Promise<CliFileResult[] | null>;
 }
 
-declare const CliProcessRegistry_TOKEN = "cli-process-registry";
+declare const CliProcessRegistry_TOKEN: any;
 declare class CliProcessRegistry implements ICliProcessRegistry {
     private nextPid;
     private processes;
     private _currentPid;
     private maxHistory;
     get currentPid(): number | undefined;
-    register(command: string): {
+    register(command: string, options?: ICliProcessRegisterOptions): {
         pid: number;
         abortController: AbortController;
     };
@@ -1804,7 +2503,7 @@ declare class CliProcessRegistry implements ICliProcessRegistry {
 }
 
 /**
- * Global environment variable store for the CLI session.
+ * Environment variables for the CLI.
  *
  * Variables set here are available to all commands via `$VAR` / `${VAR}`
  * substitution in the executor. Commands can also read/write the store
@@ -1813,29 +2512,106 @@ declare class CliProcessRegistry implements ICliProcessRegistry {
 interface ICliEnvironment {
     /** Get a variable value (undefined if not set). */
     get(name: string): string | undefined;
-    /** Set a variable. */
-    set(name: string, value: string): void;
-    /** Remove a variable. */
-    unset(name: string): void;
+    /**
+     * Set a variable: for the signed-in user (`'user'`, the default, saved),
+     * for everyone (`'global'`, saved) or for this terminal only (`'session'`).
+     */
+    set(name: string, value: string, scope?: CliEnvironmentScope): void;
+    /**
+     * Remove a variable. Without a scope it is removed for this terminal and
+     * the user (and hidden when it still comes from a shared or built-in
+     * value); `'global'` removes the shared value.
+     */
+    unset(name: string, scope?: CliEnvironmentScope): void;
     /** Get all variables as a record. */
     getAll(): Record<string, string>;
     /** Check if a variable is set. */
     has(name: string): boolean;
-}
-declare const ICliEnvironment_TOKEN = "cli-environment";
+    /** Where the current value of `name` comes from. */
+    scopeOf?(name: string): CliEnvironmentSource | undefined;
+}
+declare const ICliEnvironment_TOKEN: any;
+/** Where a variable is set: this terminal, the signed-in user, or everyone. */
+type CliEnvironmentScope = 'session' | 'user' | 'global';
+/** Where a value comes from: a scope, or computed / built in (`HOME`, `SHELL`, …). */
+type CliEnvironmentSource = CliEnvironmentScope | 'builtin';
+/** What one user (or the signed-out session, key '') changed: values set and defaults removed. */
+interface CliEnvironmentProfile {
+    vars: Record<string, string>;
+    unset: string[];
+}
+/** Saved environment: one profile per user name ('' when nobody is signed in). */
+type CliEnvironmentSnapshot = Record<string, CliEnvironmentProfile>;
+/**
+ * One saved change, applied by the host to the latest saved state (so two
+ * tabs changing different variables never overwrite each other).
+ */
+type CliEnvironmentChange = {
+    scope: 'user';
+    profile: string;
+    name: string;
+    value: string;
+} | {
+    scope: 'user';
+    profile: string;
+    name: string;
+    unset: true;
+    hide: boolean;
+} | {
+    scope: 'global';
+    name: string;
+    value: string;
+} | {
+    scope: 'global';
+    name: string;
+    unset: true;
+};
 /**
  * Default in-memory implementation.
- * Seeded with some standard variables on construction.
+ *
+ * A variable resolves, in order, from this terminal's variables
+ * (`NAME=value`), the current user's own (`export`), the shared ones
+ * (`export --global`), then bound live values (USER, HOME, PWD follow the
+ * session and directory), then the standard variables seeded on
+ * construction. Each user has a separate set, so `su`/`login` switch
+ * environments, and `onChange` lets the host save each change.
  */
 declare class CliEnvironment implements ICliEnvironment {
-    private readonly vars;
+    private readonly defaults;
+    /** Variables computed on read; a user's own value wins over them. */
+    private readonly bound;
+    private readonly profiles;
+    private readonly global;
+    private readonly session;
+    private profileKey;
+    /** Called after every saved change (user or global), to persist it. */
+    onChange?: (change: CliEnvironmentChange) => void;
     constructor();
+    /** Compute a variable on every read; the seeded value is the fallback while it returns nothing. */
+    bind(name: string, resolver: () => string | null | undefined): void;
+    /** Pick whose changes apply (the signed-in user's name, '' when signed out). */
+    setProfileResolver(resolver: () => string | null | undefined): void;
+    /** Restore saved profiles and shared variables (replaces the saved ones in memory). */
+    load(snapshot: CliEnvironmentSnapshot | undefined, global?: Record<string, string>): void;
+    snapshot(): CliEnvironmentSnapshot;
+    /** The shared variables. */
+    globals(): Record<string, string>;
     get(name: string): string | undefined;
-    set(name: string, value: string): void;
-    unset(name: string): void;
+    scopeOf(name: string): CliEnvironmentSource | undefined;
+    set(name: string, value: string, scope?: CliEnvironmentScope): void;
+    unset(name: string, scope?: CliEnvironmentScope): void;
     getAll(): Record<string, string>;
     has(name: string): boolean;
-}
+    private profileOf;
+}
+/** Apply one change to saved state (the host does this under the cross-tab lock). */
+declare function applyEnvironmentChange(state: {
+    profiles?: CliEnvironmentSnapshot;
+    global?: Record<string, string>;
+}, change: CliEnvironmentChange): {
+    profiles: CliEnvironmentSnapshot;
+    global: Record<string, string>;
+};
 
 declare class CliDragDropService implements ICliDragDropService {
     private readonly _container;
@@ -1847,6 +2623,58 @@ declare class CliDragDropService implements ICliDragDropService {
     destroy(): void;
 }
 
+/**
+ * Default HTTP client implementation.
+ *
+ * Wraps the global `fetch()` and automatically merges an abort signal
+ * so that in-flight requests are cancelled when the user presses Ctrl+C.
+ *
+ * Created per-command by the executor — each instance is bound to the
+ * command's own AbortSignal.
+ */
+declare class CliHttpClient implements ICliHttpClient {
+    private readonly signal?;
+    constructor(signal?: AbortSignal | undefined);
+    fetch(url: string, init?: RequestInit): Promise<Response>;
+    get<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
+    post<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
+    put<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
+    patch<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
+    delete<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
+    head(url: string, options?: CliHttpRequestOptions): Promise<Response>;
+    options<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
+    private jsonRequest;
+    private isRawBody;
+    /**
+     * Merge the command signal with any additional signals (caller, timeout).
+     * Uses AbortSignal.any() when available, falls back to a manual composite
+     * controller for older browsers (pre-Chrome 116 / Safari 17.4).
+     */
+    private mergeSignal;
+}
+
+declare class CliNotifier implements ICliNotifier {
+    private _current;
+    private readonly _change$;
+    readonly change$: rxjs.Observable<any>;
+    get current(): CliNotification | undefined;
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    clear(): void;
+    private set;
+}
+
+/** Default {@link ICliPermissionRegistry}: permissions declared by modules. */
+declare class CliPermissionRegistry implements ICliPermissionRegistry {
+    private readonly definitions;
+    register(definitions: CliPermissionDefinition[], module?: string): void;
+    unregister(module: string): void;
+    list(): CliPermissionDefinition[];
+    get(name: string): CliPermissionDefinition | undefined;
+}
+
 declare class OverlayAddon implements ITerminalAddon {
     private terminal;
     private overlayNode;
@@ -1903,23 +2731,125 @@ declare class CliKeyValueStore implements ICliKeyValueStore {
 declare class CliStateStore implements ICliStateStore {
     private readonly services;
     readonly name: string;
-    private readonly initialState;
     private state$;
-    private storageKey;
-    constructor(services: ICliServiceProvider, name: string, initialState: CliState);
+    /** Signed-in user, for `scope: 'user'` stores. */
+    private user?;
+    private initialState;
+    private options;
+    /** The first load from storage (see `initialize`). */
+    private loading?;
+    private loaded;
+    /** Keys changed before the saved state was loaded: they win over it. */
+    private readonly changedBeforeLoad;
+    /** Keys changed since the last save (only these are written). */
+    private readonly unsaved;
+    /** When each key was last changed here (`updateState`), to tell local edits from synced ones. */
+    private readonly editedAt;
+    private edits;
+    /** `reset()` since the last save: the whole state is written. */
+    private replaceOnSave;
+    /**
+     * Each key as last loaded, saved or received (JSON), to also find keys
+     * changed in place without `updateState`.
+     */
+    private baseline;
+    private persistScheduled;
+    /**
+     * Called after the state was saved (set by the store manager to share it
+     * with other tabs).
+     */
+    onPersisted?: (storageKey: string, state: CliState) => void;
+    constructor(services: ICliServiceProvider, name: string, initialState: CliState, options?: CliStateStoreOptions);
+    /** Key the state is saved under. */
+    get key(): string;
+    /**
+     * Saved per store, or per signed-in user for `scope: 'user'` (signed
+     * out, the state is shared like a global store).
+     */
+    private get storageKey();
+    /**
+     * The signed-in user changed: a `scope: 'user'` store switches to that
+     * user's saved state (unsaved changes of the previous user are dropped,
+     * so save before switching users).
+     */
+    setUser(user: string | undefined): void;
+    /** Whether changes saved by other tabs are applied to this store. */
+    get syncAcrossTabs(): boolean;
+    /** A session store lives in this terminal only and is never saved. */
+    private get isSession();
     getState<T extends CliState = CliState>(): T;
     updateState(newState: Partial<CliState>): void;
     select<K>(selector: (state: CliState) => K): Observable<K>;
     subscribe(callback: (state: CliState) => void): Subscription;
     reset(): void;
+    /**
+     * Save the state. The saved state is loaded first, so saving before the
+     * store was loaded never replaces data with the initial state.
+     */
     persist(): Promise<void>;
+    /**
+     * Change the state from its latest saved value and save it, atomically:
+     * under the cross-tab lock, `change` gets the state as saved (plus this
+     * terminal's unsaved changes) and its result is merged and written. Two
+     * terminals updating the same key never lose each other's change, e.g.
+     * both adding an item to a list. Without storage (or for a session
+     * store) it is a plain `updateState`.
+     */
+    update(change: (state: CliState) => Partial<CliState>): Promise<void>;
     initialize(): Promise<void>;
+    reload(): Promise<void>;
+    /**
+     * Add defaults for keys the store does not have yet (when it was first
+     * created without them, e.g. read before its command registered).
+     */
+    applyDefaults(defaults: CliState): void;
+    /** Merge store options (later options win). */
+    setOptions(options: CliStateStoreOptions): void;
+    /**
+     * State saved by another tab or terminal: apply it without saving again,
+     * keeping the keys changed here and not saved yet.
+     */
+    applySaved(state: CliState): void;
+    /**
+     * Another tab or terminal saved this store: apply what is saved now.
+     * Messages can arrive out of order (one sent before this terminal's own
+     * save can arrive after it), so storage, not the message, is the truth.
+     * Reads are chained so the last one applied is the latest.
+     */
+    refreshFromStorage(fallback?: CliState): Promise<void>;
+    private refreshing;
+    /**
+     * Complete the BehaviorSubject so all subscribers are notified
+     * and no further emissions occur. Called during engine teardown.
+     */
+    dispose(): void;
+    private load;
+    /**
+     * Save the keys changed here, merged into the saved state (the whole
+     * state after `reset()` or a migration). Runs under a lock shared by all
+     * tabs, so two terminals saving at once do not lose each other's keys.
+     * Keys others saved meanwhile are applied here.
+     */
+    private write;
+    /** Keys changed here since the last load, save or received state. */
+    private changedKeys;
+    private setBaseline;
+    private pick;
+    private get versionKey();
+    /** With `autoPersist`, save once after the changes of this tick. */
+    private schedulePersist;
 }
 
 interface CliEngineOptions extends CliOptions {
     terminalOptions?: Partial<ITerminalOptions & ITerminalInitOnlyOptions>;
     /** Optional snapshot to restore on start() */
     snapshot?: CliEngineSnapshot;
+    /**
+     * Explicit URL of `qodalis_cli_wasm_bg.wasm` (optional accelerator). When
+     * omitted it is looked up next to the page (`document.baseURI`), then at
+     * `/assets/wasm/` and `/wasm/`; the CLI works without it.
+     */
+    wasmUrl?: string;
 }
 declare class CliEngine {
     private readonly container;
@@ -1938,6 +2868,11 @@ declare class CliEngine {
     private resizeScheduled;
     private bootService?;
     private dragDropService?;
+    private _startedAt?;
+    private terminalOptions;
+    private _isBooted;
+    private resolveBooted;
+    private readonly bootedPromise;
     constructor(container: HTMLElement, options?: CliEngineOptions | undefined);
     /**
      * Register a CLI module to be loaded on start().
@@ -1964,9 +2899,47 @@ declare class CliEngine {
      */
     registerService(token: string, value: any): void;
     /**
-     * Initialize the terminal, wire up services, boot modules, and show welcome message.
+     * Start the CLI: set up the terminal and services, boot the modules
+     * (reporting progress in the terminal), then hand over to the prompt.
+     *
+     * Phases, in order:
+     *  1. terminal         xterm.js in the container
+     *  2. services         service container, executor, execution context
+     *  3. boot report      hold typed keys, show the boot log
+     *  4. runtime          environment, background services, servers
+     *  5. modules          core + welcome + server + user modules
+     *  6. completion       tab-completion providers
+     *  7. ready            clear the report, replay typed keys, `isBooted`
+     *  8. after boot       `onAfterBoot` hooks (welcome message), snapshot
      */
     start(): Promise<void>;
+    /** 1. Wait for the container to have a size, then create xterm.js. */
+    private setupTerminal;
+    /** 2. Service container, boot service, executor and execution context. */
+    private setupServices;
+    /**
+     * 3. Keep what the user types until the terminal is ready (replayed at
+     * the first prompt) and start the boot report (configurable).
+     */
+    private beginBootReport;
+    /** 4. Environment variables, background services, server auth and manager. */
+    private registerRuntimeServices;
+    /** 4. Connect to the configured servers, one boot step each. */
+    private connectServers;
+    /**
+     * 5. Built-in welcome and server modules, the app's modules, and the
+     * greeting, which runs after every other `onAfterBoot` hook.
+     */
+    private modulesToBoot;
+    /** 7. Replace the boot report with the terminal and mark the CLI booted. */
+    private completeBoot;
+    /**
+     * Boot threw: never leave the terminal unusable. Keep the report with the
+     * error on screen, show the cursor and hand over typed keys.
+     */
+    private failBoot;
+    /** 8. `onAfterBoot` hooks by priority (lower first); one failing hook does not stop the rest. */
+    private runAfterBootHooks;
     /**
      * Clean up terminal and event listeners.
      */
@@ -1988,7 +2961,23 @@ declare class CliEngine {
      */
     getRegistry(): CliCommandProcessorRegistry;
     /**
-     * Execute a command programmatically.
+     * `true` once boot has completed: modules are set up and the terminal
+     * accepts input. `onAfterBoot` hooks (welcome message) run right after.
+     */
+    get isBooted(): boolean;
+    /**
+     * Resolves when boot has completed (see `isBooted`). Never rejects; if
+     * `start()` fails it stays pending.
+     */
+    get booted(): Promise<void>;
+    /**
+     * Timestamp (ms since epoch) when the engine finished starting.
+     */
+    get startedAt(): number | undefined;
+    /**
+     * Execute a command programmatically, behaving the same as if the user
+     * typed it and pressed Enter: echoes the command, adds it to history,
+     * executes it, and shows a new prompt afterwards.
      */
     execute(command: string): Promise<void>;
     /**
@@ -2002,8 +2991,6 @@ declare class CliEngine {
      * source, the restored content may reflow differently.
      */
     private restoreSnapshot;
-    private getTerminalOptions;
-    private initializeTerminal;
     private handleResize;
     /**
      * Call fitAddon.fit() only when the container has non-zero dimensions.
@@ -2017,51 +3004,218 @@ declare class CliEngine {
      * so intermediate resize events cannot leave stale artefacts.
      */
     private deferResizeFix;
-    /**
-     * Wait until the container element has non-zero dimensions.
-     * xterm.js requires the host element to be laid out before open() is called.
-     */
-    private waitForLayout;
 }
 
+interface TerminalSetupResult {
+    terminal: Terminal;
+    fitAddon: FitAddon;
+    serializeAddon: SerializeAddon;
+    dragDropService: CliDragDropService;
+    wheelListener: (e: WheelEvent) => void;
+}
+/**
+ * Default terminal font size: 20px, or 14px on phone-sized viewports so a
+ * line still fits a useful number of columns (about 26 at 20px on a 390px screen).
+ */
+declare function defaultFontSize(): number;
+/**
+ * Merge user-supplied terminal options with sensible defaults.
+ */
+declare function getTerminalOptions(userOptions?: Partial<ITerminalOptions & ITerminalInitOnlyOptions>): ITerminalOptions & ITerminalInitOnlyOptions;
+/**
+ * Create and configure an xterm.js Terminal with all required addons,
+ * open it into the given container, and return the instances.
+ */
+declare function initializeTerminal(container: HTMLElement, opts: ITerminalOptions & ITerminalInitOnlyOptions): TerminalSetupResult;
+/**
+ * Wait until the container element has non-zero dimensions.
+ * xterm.js requires the host element to be laid out before open() is called.
+ * Rejects after {@link LAYOUT_TIMEOUT_MS} if the container stays hidden.
+ */
+declare function waitForLayout(container: HTMLElement): Promise<void>;
+
+/**
+ * In-memory publish/subscribe bus of one terminal. Handlers run
+ * synchronously in subscription order; a throwing handler is reported to
+ * `onHandlerError` and does not stop delivery. Keeps the last
+ * {@link CLI_EVENT_HISTORY_SIZE} events; nothing is persisted.
+ */
+declare class CliEventBus implements ICliEventBus {
+    private readonly onHandlerError;
+    private readonly historySize;
+    private readonly subject;
+    private readonly recent;
+    private disposed;
+    constructor(onHandlerError?: (error: unknown, event: CliEvent) => void, historySize?: number);
+    emit<K extends CliEventType>(type: K, data: CliEventMap[K], options?: CliEmitOptions): void;
+    emit<T = unknown, K extends string = string>(type: K & CustomEventType<K>, data?: T, options?: CliEmitOptions): void;
+    on<K extends CliEventType>(pattern: K, handler: CliEventHandler<CliEventMap[K]>): () => void;
+    on<T = unknown>(pattern: string, handler: CliEventHandler<T>): () => void;
+    once<K extends CliEventType>(pattern: K, handler: CliEventHandler<CliEventMap[K]>): () => void;
+    once<T = unknown>(pattern: string, handler: CliEventHandler<T>): () => void;
+    events$<K extends CliEventType>(pattern: K): Observable<CliEvent<CliEventMap[K]>>;
+    events$<T = unknown>(pattern?: string): Observable<CliEvent<T>>;
+    history<K extends CliEventType>(pattern: K, limit?: number): CliEvent<CliEventMap[K]>[];
+    history<T = unknown>(pattern?: string, limit?: number): CliEvent<T>[];
+    /** Stop delivering events and complete all observables. */
+    dispose(): void;
+}
+
+/**
+ * Default implementation of the translation service.
+ *
+ * Maintains a map of locale -> flat key-value translations.
+ * The 'en' locale is always implicitly available via defaultValue fallbacks.
+ * Supports simple {param} interpolation.
+ */
+declare class CliTranslationService implements ICliTranslationService {
+    private locale;
+    private readonly translations;
+    t(key: string, defaultValue: string, params?: Record<string, string | number>): string;
+    getLocale(): string;
+    setLocale(locale: string): void;
+    addTranslations(locale: string, translations: Record<string, string>): void;
+    getAvailableLocales(): string[];
+}
+
+interface InitializeServicesOptions {
+    registry: CliCommandProcessorRegistry;
+    pendingServices: CliProvider[];
+    dragDropService?: CliDragDropService;
+}
+interface InitializeServicesResult {
+    services: CliServiceContainer;
+    events: CliEventBus;
+    logger: CliLogger;
+    commandHistory: CliCommandHistory;
+    stateStoreManager: CliStateStoreManager;
+    processRegistry: CliProcessRegistry;
+    translator: CliTranslationService;
+}
+/**
+ * Build and populate the service container with all core services.
+ * Takes the registry, pending (user-registered) services, and the drag-drop
+ * service instance, and returns all initialized services ready for wiring
+ * into the execution context.
+ */
+declare function initializeServices(options: InitializeServicesOptions): Promise<InitializeServicesResult>;
+
+/** Service token holding the name of the framework hosting the CLI. */
+declare const CLI_FRAMEWORK_SERVICE = "cli-framework";
+/** What a framework wrapper passes to an engine: shared by components, providers and config contexts. */
+interface CliHostConfig {
+    modules?: ICliModule[];
+    /** @deprecated Use modules instead. */
+    processors?: ICliCommandProcessor[];
+    options?: CliEngineOptions;
+    /** Extra services registered by token before start. */
+    services?: Record<string, any>;
+}
+interface CreateCliEngineConfig extends CliHostConfig {
+    /** Reported by `version`, `debug` and `feedback`, e.g. 'React'. */
+    framework?: string;
+    /** Terminal state to restore on start. */
+    snapshot?: CliEngineSnapshot;
+}
+/**
+ * Create an engine for `container` with the services, modules and
+ * processors of a wrapper registered (in that order). Call `start()` on it.
+ */
+declare function createCliEngine(container: HTMLElement, config?: CreateCliEngineConfig): CliEngine;
+/**
+ * Resolve a component's config: each field set locally wins over the one
+ * inherited from a surrounding config provider.
+ */
+declare function resolveCliHostConfig(local: CliHostConfig, inherited?: CliHostConfig | null): CliHostConfig;
+/** Merge option objects key by key: `local` overrides `inherited`. */
+declare function mergeCliOptions<T extends object>(local: T | undefined, inherited: object | undefined): T | undefined;
+
 declare class CliServerConnection {
     private readonly _config;
     private readonly _backgroundServices?;
+    private readonly _logger?;
+    private readonly _authService?;
     private _connected;
     private _commands;
     private _capabilities;
     private _eventSocket;
+    private _apiVersion;
+    private _basePath;
+    private _wsReconnectAttempts;
+    private _wsReconnectTimer;
+    /** True once this connection registered its `server-events:<name>` background service */
+    private _eventServiceRegistered;
+    private static readonly WS_MAX_RECONNECT_ATTEMPTS;
+    private static readonly WS_MAX_RECONNECT_DELAY_MS;
+    private _healthCheckTimer;
+    private _healthCheckAttempts;
+    private static readonly HEALTH_CHECK_INTERVAL_MS;
+    private static readonly HEALTH_CHECK_MAX_ATTEMPTS;
     onDisconnect?: () => void;
-    constructor(_config: CliServerConfig, _backgroundServices?: ICliBackgroundServiceRegistry | undefined);
+    onReconnected?: () => void;
+    constructor(_config: CliServerConfig, _backgroundServices?: ICliBackgroundServiceRegistry, _logger?: ICliLogger, _authService?: ICliServerAuthService);
     get config(): CliServerConfig;
     get connected(): boolean;
     get commands(): CliServerCommandDescriptor[];
     get capabilities(): CliServerCapabilities | null;
+    get apiVersion(): number;
+    /**
+     * Resolve auth headers for this server connection.
+     * Uses the auth service (which merges config headers with registered
+     * ICliServerAuthTokenProviders), or falls back to config headers directly.
+     */
+    resolveAuthHeaders(): Record<string, string>;
+    /**
+     * WebSocket URL for this server with auth: single-use upgrade params from
+     * auth providers when available, otherwise headers copied into the URL.
+     */
+    buildWebSocketUrl(path: string): Promise<string>;
     connect(): Promise<void>;
     disconnect(): void;
+    startHealthCheck(): void;
+    private scheduleNextHealthCheck;
+    stopHealthCheck(): void;
     fetchCommands(): Promise<CliServerCommandDescriptor[]>;
     fetchCapabilities(): Promise<CliServerCapabilities | null>;
     execute(command: CliProcessCommand): Promise<CliServerResponse>;
+    executeStream(command: CliProcessCommand, onOutput: (output: CliServerOutput) => void): Promise<{
+        exitCode: number;
+    }>;
     ping(): Promise<boolean>;
+    /** Whether the server answers HTTP at all (any status: it is running). */
+    private answers;
     private connectEventSocket;
     private connectEventSocketDirect;
+    private connectEventSocketDirectAsync;
+    /**
+     * The server closes the event socket with 4401 when the session behind it
+     * ended (logout, revoke, expiry). Retrying with the same credentials cannot
+     * succeed; the auth layer reconnects the server when the session changes.
+     */
+    private isSessionEndedClose;
     private handleServerDisconnect;
     private closeEventSocket;
     private closeEventSocketDirect;
+    private scheduleWsReconnect;
+    private httpFetchWithRetry;
     private httpFetch;
     private normalizeUrl;
     private toWebSocketUrl;
 }
 
 /**
- * Execute a command on a specific server connection and render the response.
- * Shared by both single-proxy and multi-proxy processors.
+ * Render a single CliServerOutput to the terminal.
  */
-declare function executeOnServer(connection: CliServerConnection, serverName: string, descriptor: CliServerCommandDescriptor, command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+declare function renderSingleOutput(output: CliServerOutput, context: ICliExecutionContext): void;
 /**
  * Render a CliServerResponse to the terminal.
  */
 declare function renderServerResponse(response: CliServerResponse, context: ICliExecutionContext): void;
+/**
+ * Execute a command on a specific server connection and render the response.
+ * Shared by both single-proxy and multi-proxy processors.
+ */
+declare function executeOnServer(connection: CliServerConnection, serverName: string, descriptor: CliServerCommandDescriptor, command: CliProcessCommand, context: ICliExecutionContext, commandPath?: string[]): Promise<void>;
 declare class CliServerProxyProcessor implements ICliCommandProcessor {
     private readonly connection;
     private readonly descriptor;
@@ -2071,9 +3225,12 @@ declare class CliServerProxyProcessor implements ICliCommandProcessor {
     description?: string;
     version?: string;
     metadata?: CliProcessorMetadata;
-    parameters?: ICliCommandParameterDescriptor[];
+    parameters?: ICliCommandParameterDescriptor$1[];
     processors?: ICliCommandProcessor[];
-    constructor(connection: CliServerConnection, descriptor: CliServerCommandDescriptor, serverName: string);
+    acceptsRawInput?: boolean;
+    /** Full command path from root to this processor (e.g. ["aws", "lambda", "list"]) */
+    private readonly commandPath;
+    constructor(connection: CliServerConnection, descriptor: CliServerCommandDescriptor, serverName: string, isNested?: boolean, parentPath?: string[]);
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
 }
 
@@ -2097,31 +3254,41 @@ declare class CliServerMultiProxyProcessor implements ICliCommandProcessor {
     command: string;
     description?: string;
     metadata?: CliProcessorMetadata;
-    parameters?: ICliCommandParameterDescriptor[];
+    parameters?: ICliCommandParameterDescriptor$1[];
     processors?: ICliCommandProcessor[];
-    constructor(entries: MultiProxyEntry[], provider: DefaultServerProvider);
+    acceptsRawInput?: boolean;
+    /** Full command path from root to this processor */
+    private readonly commandPath;
+    constructor(entries: MultiProxyEntry[], provider: DefaultServerProvider, parentPath?: string[]);
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
 }
 
-declare const CliServerManager_TOKEN = "cli-server-manager";
+declare const CliServerManager_TOKEN: any;
 declare class CliServerManager implements DefaultServerProvider {
     private readonly registry;
+    private readonly authService?;
+    private readonly events?;
     readonly connections: Map<string, CliServerConnection>;
     private _logger?;
+    private _cliLogger?;
     private _defaultServer;
+    /** Bare-name aliases this manager registered (only these are ever removed) */
+    private readonly _bareAliases;
     private _backgroundServices?;
-    constructor(registry: ICliCommandProcessorRegistry);
+    constructor(registry: ICliCommandProcessorRegistry, authService?: ICliServerAuthService, events?: ICliEventBus);
     get defaultServer(): string | null;
+    preferredServer(): string | null;
     setDefaultServer(name: string | null): void;
     connectAll(servers: CliServerConfig[], logger?: {
         warn(msg: string): void;
         info(msg: string): void;
-    }, backgroundServices?: ICliBackgroundServiceRegistry): Promise<void>;
+    }, backgroundServices?: ICliBackgroundServiceRegistry, cliLogger?: ICliLogger): Promise<void>;
     reconnect(name: string): Promise<{
         success: boolean;
         commandCount: number;
     }>;
     getConnection(name: string): CliServerConnection | undefined;
+    private emitConnected;
     private handleDisconnect;
     private unregisterServerProcessors;
     private unregisterBareAliases;
@@ -2131,37 +3298,60 @@ declare class CliServerManager implements DefaultServerProvider {
 
 declare function createServerModule(): ICliModule;
 
+/**
+ * `server`: the servers this terminal is connected to (configured by the
+ * app in `options.servers`). Their commands are available directly (`echo`)
+ * and namespaced (`node:echo`).
+ */
 declare class CliServerCommandProcessor implements ICliCommandProcessor {
     command: string;
+    aliases: string[];
     description: string;
     metadata: {
-        icon: CliIcon;
+        icon: any;
         module: string;
         sealed: boolean;
     };
+    stateConfiguration: CliStateConfiguration;
     processors: ICliCommandChildProcessor[];
+    /** Restore the default server saved by `server default <name>`. */
+    initialize(context: ICliExecutionContext): Promise<void>;
+    /** `server` alone: the servers, then what can be done with them. */
     processCommand(_command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
 }
 
 declare class CliSshCommandProcessor implements ICliCommandProcessor {
     command: string;
+    aliases: string[];
     description: string;
     acceptsRawInput: boolean;
     valueRequired: boolean;
     metadata: CliProcessorMetadata;
-    parameters?: ICliCommandParameterDescriptor[];
-    private socket;
-    private context;
+    parameters?: ICliCommandParameterDescriptor$1[];
     processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
-    onData(data: string, context: ICliExecutionContext): Promise<void>;
-    onResize(cols: number, rows: number, _context: ICliExecutionContext): void;
-    onDispose(_context: ICliExecutionContext): void;
+    /**
+     * Full-screen handler for one session: input, resize and disposal go to
+     * that session's socket only.
+     */
+    private fullScreenHandler;
     private resolveServer;
+    /** Why `name` cannot be used: unknown, unreachable or without a shell. */
+    private writeWhyNotAvailable;
+    /** No server has a shell: say whether none is configured, connected or shell-enabled. */
+    private writeNoShellServers;
+    writeDescription(context: ICliExecutionContext): void;
     private executeInteractive;
     private executeOneShot;
+    /** `ssh <server> <cmd...>` → `<cmd...>` exactly as typed */
+    private remoteCommandFromRaw;
     private buildShellUrl;
     private cleanup;
 }
+declare function describeShellClose(event: {
+    code?: number;
+    reason?: string;
+}, serverName: string): string | null;
 
 /**
  * Result of executing a command through the test harness.
@@ -2207,20 +3397,30 @@ declare class CliTestHarness {
     readonly registry: CliCommandProcessorRegistry;
     readonly executor: CliCommandExecutor;
     readonly services: CliServiceContainer;
+    /** Shared by every command: add a language pack and switch locale to test translations. */
+    readonly translator: CliTranslationService;
     private readonly stateStoreManager;
+    private readonly initialized;
     private readonly processRegistry;
     /** Current user session — set via setUserSession() */
     userSession?: ICliUserSession;
     /** Reader responses — set via setReaderResponses() for interactive commands */
     private readerResponses;
+    private userSessionProvider?;
     constructor();
+    /**
+     * Resolve `context.userSession` on every command from this function
+     * (e.g. a session service), instead of the value set via setUserSession().
+     */
+    setUserSessionProvider(provider: () => ICliUserSession | undefined): void;
     /**
      * Register a service in the test container.
      */
     registerService(token: any, value: any): void;
     /**
      * Register a command processor. If the processor has an `initialize()`
-     * method, it will be called with a context wired to the harness services.
+     * method, it is called (with the processor's own state store, as in the
+     * engine) before the first `execute()`, or by `initializeProcessors()`.
      */
     registerProcessor(processor: ICliCommandProcessor): void;
     /**
@@ -2232,6 +3432,8 @@ declare class CliTestHarness {
      * Call this after registering all services and processors.
      */
     initializeProcessors(): Promise<void>;
+    /** As the engine's boot: link sub-commands to their parent, then initialize. */
+    private initializeTree;
     /**
      * Set the active user session. Commands that check `context.userSession`
      * will see this session.
@@ -2262,6 +3464,10 @@ interface ICliWasmAccelerator {
     prefixMatch(candidates: string[], prefix: string): string[];
     /** Longest common prefix of the given strings. */
     commonPrefix(strings: string[]): string;
+    /** Register a named rule set for syntax highlighting tokenization. */
+    registerRuleSet(ruleSetId: string, rules: string): void;
+    /** Tokenize a line using a previously registered rule set. Returns newline-separated "start,end,tokenType" entries. */
+    tokenizeLine(line: string, ruleSetId: string): string;
 }
 
 /**
@@ -2275,6 +3481,9 @@ declare class JsFallbackAccelerator implements ICliWasmAccelerator {
         text: string;
     };
     prefixMatch(candidates: string[], prefix: string): string[];
+    private ruleSets;
+    registerRuleSet(ruleSetId: string, rules: string): void;
+    tokenizeLine(line: string, ruleSetId: string): string;
     commonPrefix(strings: string[]): string;
 }
 
@@ -2299,4 +3508,511 @@ declare function getAccelerator(): ICliWasmAccelerator;
  */
 declare function isWasmAccelerated(): boolean;
 
-export { API_VERSION, type ActiveInputRequest, type ActiveInputRequestType, CLi_Name_Art, CapturingTerminalWriter, type CdnSourceName, CliAliasCommandProcessor, CliArgsParser, CliBackgroundServiceRegistry_TOKEN, CliBase64CommandProcessor, CliBoot, CliCalCommandProcessor, CliCaptureCommandProcessor, CliClearCommandProcessor, CliClipboard, CliClipboardCommandProcessor, CliColorCommandProcessor, CliCommandExecutionContext, CliCommandExecutor, CliCommandHistory, CliCommandHistory_TOKEN, CliCommandProcessorRegistry, CliConfigureCommandProcessor, CliConvertCommandProcessor, CliDebugCommandProcessor, CliDefaultPingServerService, CliDiffCommandProcessor, CliDragDropService, CliEchoCommandProcessor, CliEngine, type CliEngineOptions, CliEnvCommandProcessor, CliEnvironment, CliEvalCommandProcessor, CliExecutionContext, type CliExecutionContextDeps, CliExecutionProcess, CliExportCommandProcessor, CliFeedbackCommandProcessor, CliFontSizeCommandProcessor, CliHashCommandProcessor, CliHelpCommandProcessor, CliHexCommandProcessor, CliHistoryCommandProcessor, CliHotKeysCommandProcessor, CliInputReader, type CliInputReaderHost, CliJsonCommandProcessor, CliJwtCommandProcessor, CliKeyValueStore, CliKillCommandProcessor, CliLogger, CliLoremCommandProcessor, CliModuleRegistry_TOKEN, CliNanoCommandProcessor, CliOpenCommandProcessor, CliPackageManagerService, CliPackageManagerService_TOKEN, CliPackagesCommandProcessor, CliPingCommandProcessor, CliProcessRegistry, CliProcessRegistry_TOKEN, CliProcessorsRegistry_TOKEN, CliPsCommandProcessor, CliRandomCommandProcessor, CliScreenCommandProcessor, CliSeqCommandProcessor, CliServerCommandProcessor, CliServerConnection, CliServerManager, CliServerManager_TOKEN, CliServerMultiProxyProcessor, CliServerProxyProcessor, CliServiceContainer, CliServicesCommandProcessor, CliSleepCommandProcessor, CliSnippetCommandProcessor, CliSshCommandProcessor, CliStateStore, CliStateStoreManager, CliStateStoreManager_TOKEN, CliTerminalProgressBar, CliTerminalSpinner, CliTerminalTextAnimator, CliTerminalWriter, CliTestHarness, type CliTestResult, CliThemeCommandProcessor, CliTimeCommandProcessor, CliTimestampCommandProcessor, CliUnAliasCommandProcessor, CliUnameCommandProcessor, CliUnsetCommandProcessor, CliUptimeCommandProcessor, CliUrlCommandProcessor, CliVersionCommandProcessor, type CliWelcomeMessageConfig, CliYesCommandProcessor, CommandParser, type CommandParserOutput, type CommandPart, type ConfigureState, type DefaultServerProvider, type DiffLine, type DiffType, type ICliEnvironment, ICliEnvironment_TOKEN, type ICliExecutionHost, ICliPingServerService_TOKEN, type ICliStateStoreManager, type ICliWasmAccelerator, JsFallbackAccelerator, LIBRARY_VERSION, type MultiProxyEntry, OverlayAddon, type ParsedArg, type ParsedToken, ProcessExitedError, ScriptLoaderService, type ThemeState, builtinProcessors, computeDiff, contextGlobalParameter, createServerModule, executeOnServer, formatDiff, getAccelerator, getCliNameArt, getGreetingBasedOnTime, groupBy, helpGlobalParameter, hotkeysInfo, initWasmAccelerator, isWasmAccelerated, miscProcessors, openLink, reconcileArgs, renderServerResponse, systemProcessors, themeInfos, themes, versionGlobalParameter, welcomeModule };
+/** One terminal inside a tab. */
+interface CliPanelPane {
+    id: number;
+    widthPercent: number;
+    /** Snapshot to restore when the pane's engine starts (used by "Duplicate"). */
+    snapshot?: CliEngineSnapshot;
+}
+/** One tab of the panel: a title and one or more panes side by side. */
+interface CliPanelTab {
+    id: number;
+    title: string;
+    isEditing: boolean;
+    panes: CliPanelPane[];
+}
+interface CliPanelContextMenu {
+    visible: boolean;
+    x: number;
+    y: number;
+    tabId: number;
+}
+interface CliPanelServiceDetail {
+    name: string;
+    status: string;
+    description?: string;
+}
+interface CliPanelServerDetail {
+    name: string;
+    url: string;
+    connected: boolean;
+    apiVersion?: string;
+    commandCount?: number;
+}
+type CliPanelExecutionState = 'idle' | 'running';
+type CliPanelServerState = 'connected' | 'disconnected' | 'none';
+/** Status derived from the engines of a single tab. */
+interface CliPanelTabStatus {
+    executionState: CliPanelExecutionState;
+    lastCommand: {
+        name: string;
+        success: boolean;
+    } | null;
+    notification: CliNotification | null;
+}
+/** Status derived from the first engine of the active tab. */
+interface CliPanelGlobalStatus {
+    serviceCount: {
+        running: number;
+        total: number;
+    };
+    serviceDetails: CliPanelServiceDetail[];
+    serverState: CliPanelServerState;
+    serverDetails: CliPanelServerDetail[];
+    /** Milliseconds since the engine started, 0 when unknown. */
+    uptime: number;
+}
+declare const DEFAULT_TAB_STATUS: CliPanelTabStatus;
+declare const DEFAULT_GLOBAL_STATUS: CliPanelGlobalStatus;
+/**
+ * Values a host may control from the outside. A defined value wins over the
+ * panel's own state; `undefined` leaves the panel uncontrolled for that field.
+ */
+interface CliPanelControlledState {
+    collapsed?: boolean;
+    hidden?: boolean;
+    maximized?: boolean;
+    activeTabId?: number;
+    position?: CliPanelPosition;
+    height?: number;
+    width?: number;
+}
+/** Change notifications and structural events, mapped by each framework wrapper. */
+interface CliPanelCallbacks {
+    onCollapsedChange?: (collapsed: boolean) => void;
+    onHiddenChange?: (hidden: boolean) => void;
+    onMaximizedChange?: (maximized: boolean) => void;
+    onActiveTabIdChange?: (tabId: number) => void;
+    onPositionChange?: (position: CliPanelPosition) => void;
+    onHeightChange?: (height: number) => void;
+    onWidthChange?: (width: number) => void;
+    onClose?: () => void;
+    onTabAdded?: (event: {
+        tabId: number;
+    }) => void;
+    onTabClosed?: (event: {
+        tabId: number;
+    }) => void;
+    onPaneSplit?: (event: {
+        paneId: number;
+        tabId: number;
+    }) => void;
+    onPaneClosed?: (event: {
+        paneId: number;
+    }) => void;
+}
+interface CliPanelViewport {
+    width: number;
+    height: number;
+}
+interface CliPanelControllerOptions {
+    /** Panel configuration (initial state, chrome buttons, theme sync). */
+    config?: CliPanelConfig;
+    callbacks?: CliPanelCallbacks;
+    controlled?: CliPanelControlledState;
+    /** Viewport size used for maximize and resize clamping. Defaults to `window`. */
+    viewport?: () => CliPanelViewport;
+    /**
+     * Restore and persist the position through localStorage.
+     * @default true
+     */
+    persistPosition?: boolean;
+}
+/**
+ * Immutable view of the whole panel. A new object is produced on every
+ * change, so views can compare by reference.
+ */
+interface CliPanelSnapshot {
+    visible: boolean;
+    /** True once the first tab has been created (content rendered). */
+    initialized: boolean;
+    collapsed: boolean;
+    hidden: boolean;
+    maximized: boolean;
+    position: CliPanelPosition;
+    height: number;
+    width: number;
+    isHorizontal: boolean;
+    /** Status text is shown in the header for top/bottom, compact dots otherwise. */
+    showStatusIndicators: boolean;
+    panelResizing: boolean;
+    themeStyles: Record<string, string>;
+    closable: boolean;
+    resizable: boolean;
+    hideable: boolean;
+    hideAlignment: CliPanelHideAlignment;
+    syncTheme: boolean;
+    tabs: readonly CliPanelTab[];
+    activeTabId: number;
+    activePaneId: number;
+    paneResizing: boolean;
+    contextMenu: CliPanelContextMenu;
+    positionDropdownOpen: boolean;
+    servicesDropdownOpen: boolean;
+    servicesDropdownStyle: Record<string, string>;
+    serversDropdownOpen: boolean;
+    serversDropdownStyle: Record<string, string>;
+    /** Status of the active tab. */
+    status: CliPanelTabStatus;
+    tabStatuses: Readonly<Record<number, CliPanelTabStatus>>;
+    global: CliPanelGlobalStatus;
+    formattedUptime: string;
+}
+
+declare const MIN_PANE_WIDTH_PERCENT = 10;
+declare const MIN_PANEL_SIZE = 100;
+declare const DEFAULT_PANEL_HEIGHT = 600;
+declare const DEFAULT_PANEL_WIDTH = 400;
+declare const PANEL_POSITIONS: readonly CliPanelPosition[];
+/** Scale pane widths so they add up to 100. Returns new pane objects. */
+declare function normalizePaneWidths(panes: readonly CliPanelPane[]): CliPanelPane[];
+/** Give every pane the same width. Returns new pane objects. */
+declare function distributePaneWidths(panes: readonly CliPanelPane[]): CliPanelPane[];
+/**
+ * Move the divider between pane `dividerIndex` and `dividerIndex + 1` by
+ * `deltaPercent`, keeping both panes at least `MIN_PANE_WIDTH_PERCENT` wide.
+ */
+declare function resizePaneWidths(startWidths: readonly number[], dividerIndex: number, deltaPercent: number): number[];
+/** Clamp a dragged panel size between the minimum and the viewport. */
+declare function clampPanelSize(size: number, max: number): number;
+/**
+ * New panel size for a drag that started at `start` and moved by
+ * (`deltaX`, `deltaY`). Only the axis matching the position matters.
+ */
+declare function resizedPanelSize(position: CliPanelPosition, start: {
+    width: number;
+    height: number;
+}, deltaX: number, deltaY: number, viewport: CliPanelViewport): {
+    width?: number;
+    height?: number;
+};
+interface AnchorRect {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+/**
+ * Fixed-position style for a dropdown opened from `anchor`, placed on the
+ * side of the panel that faces the page.
+ */
+declare function dropdownAnchorStyle(anchor: AnchorRect, position: CliPanelPosition, viewport: CliPanelViewport): Record<string, string>;
+/** "12m", "1h05m"-style uptime label. */
+declare function formatUptime(ms: number): string;
+declare function isHorizontalPosition(position: CliPanelPosition): boolean;
+
+/** Poll interval for execution state, last command and notifications. */
+declare const EXEC_POLL_MS = 300;
+/** Poll interval for services, servers and uptime. */
+declare const GLOBAL_POLL_MS = 2000;
+/** Status of a tab from all of its pane engines. */
+declare function computeTabStatus(engines: Iterable<CliEngine>): CliPanelTabStatus;
+/** Services, servers and uptime of one engine. */
+declare function computeGlobalStatus(engine: CliEngine | undefined, now?: number): CliPanelGlobalStatus;
+interface CliPanelStatusTrackerListener {
+    onTabStatus(tabId: number, status: CliPanelTabStatus): void;
+    onGlobalStatus(status: CliPanelGlobalStatus): void;
+}
+/**
+ * Watches the engines of every tab and reports status changes. Execution
+ * state is polled quickly, services and servers slowly; engine events
+ * (notifier, background services) trigger an immediate refresh.
+ */
+declare class CliPanelStatusTracker {
+    private readonly listener;
+    private tabs;
+    private activeTabId?;
+    private globalStatus;
+    private execTimer?;
+    private globalTimer?;
+    constructor(listener: CliPanelStatusTrackerListener);
+    registerEngine(tabId: number, paneId: number, engine: CliEngine): void;
+    unregisterPane(paneId: number): void;
+    unregisterTab(tabId: number): void;
+    setActiveTab(tabId: number): void;
+    /** Recompute everything now. */
+    refresh(): void;
+    destroy(): void;
+    private ensurePolling;
+    private stopPolling;
+    private refreshTab;
+    private refreshGlobal;
+}
+
+/**
+ * Framework-agnostic state and behaviour of the collapsible CLI panel:
+ * tabs and panes, chrome (collapse, hide, maximize, position, size),
+ * menus, drag resizing, theme sync and the status bar.
+ *
+ * Views subscribe with {@link subscribe} and render {@link getSnapshot};
+ * every change produces a new immutable snapshot. Hosts may control any of
+ * the bindable values through {@link setControlled}; the matching
+ * `onXChange` callback is invoked whenever the panel wants to change it.
+ */
+declare class CliPanelController implements ICliPanelRef<CliEngine> {
+    callbacks: CliPanelCallbacks;
+    private snapshot;
+    private internal;
+    private controlled;
+    private readonly listeners;
+    private readonly engines;
+    private readonly tracker;
+    private readonly viewport;
+    private readonly persistPosition;
+    private nextTabId;
+    private nextPaneId;
+    private preHideCollapsed;
+    private previousHeight;
+    private previousWidth;
+    private panelDrag?;
+    private paneDrag?;
+    private documentListenersAttached;
+    private rootElement;
+    private themeObserver?;
+    constructor(options?: CliPanelControllerOptions);
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly getSnapshot: () => CliPanelSnapshot;
+    /** Apply a new panel configuration (chrome buttons, theme sync). */
+    setOptions(config: CliPanelConfig | undefined): void;
+    /** Replace the change callbacks (wrappers call this when their props change). */
+    setCallbacks(callbacks: CliPanelCallbacks): void;
+    /** Update host-controlled values. Unchanged values are ignored. */
+    setControlled(values: CliPanelControlledState): void;
+    /** Element containing the terminals, used for theme sync. */
+    setRootElement(element: ParentNode | null): void;
+    /**
+     * Stop timers, observers and document listeners. Engines are not
+     * destroyed (their views own them). Registering an engine again
+     * restarts status tracking, so a remounted view can reuse the controller.
+     */
+    destroy(): void;
+    /** Header collapse button: expand (creating the first tab) or collapse. */
+    toggle(): void;
+    open(): void;
+    collapse(): void;
+    toggleCollapse(): void;
+    hide(): void;
+    unhide(): void;
+    toggleHide(): void;
+    close(): void;
+    maximize(): void;
+    restore(): void;
+    toggleMaximize(): void;
+    resize(dimensions: {
+        height?: number;
+        width?: number;
+    }): void;
+    setPosition(position: CliPanelPosition): void;
+    addTab(title?: string): number;
+    closeTab(tabId: number): void;
+    selectTab(tabId: number): void;
+    renameTab(tabId: number, title: string): void;
+    /** Switch a tab's title into inline editing. */
+    startRename(tabId: number): void;
+    /** Finish inline editing; an empty value keeps the old title. */
+    commitRename(tabId: number, value: string): void;
+    cancelRename(): void;
+    /** Open a new tab next to `tabId` with a copy of its first terminal's content. */
+    duplicateTab(tabId: number): number;
+    closeOtherTabs(tabId: number): void;
+    closeTabsToTheRight(tabId: number): void;
+    closeAllTabs(): void;
+    splitPane(tabId?: number): number;
+    closePane(paneId: number): void;
+    /** A pane was clicked: make it (and its tab) active and focus its terminal. */
+    activatePane(tabId: number, paneId: number): void;
+    /** Called by the view once a pane's terminal engine is running. */
+    registerEngine(tabId: number, paneId: number, engine: CliEngine): void;
+    getEngine(paneId?: number): CliEngine | undefined;
+    getState(): CliPanelState;
+    openContextMenu(tabId: number, x: number, y: number): void;
+    closeContextMenu(): void;
+    togglePositionDropdown(): void;
+    /** `anchor` is the clicked status item; the dropdown is placed next to it. */
+    toggleServicesDropdown(anchor?: Element | null): void;
+    toggleServersDropdown(anchor?: Element | null): void;
+    /** Close the context menu and every dropdown. */
+    closeMenus(): void;
+    /** Mouse down on the panel's resize bar. */
+    startPanelResize(clientX: number, clientY: number): void;
+    /** Mouse down on the divider before pane `dividerIndex + 1` of a tab. */
+    startPaneResize(tabId: number, dividerIndex: number, clientX: number, containerWidth: number): void;
+    private readonly onPanelResizeMove;
+    private readonly onPanelResizeEnd;
+    private endPanelResize;
+    private readonly onPaneResizeMove;
+    private readonly onPaneResizeEnd;
+    private endPaneResize;
+    private readonly onDocumentClick;
+    private readonly onDocumentKeydown;
+    private syncDocumentListeners;
+    private detachDocumentListeners;
+    /** Read the first terminal's theme and derive the panel colours from it. */
+    syncThemeFromEngine(): void;
+    /**
+     * Sync now and follow the first terminal's container: the `theme`
+     * command restyles it, which re-derives the panel colours.
+     * Engines are registered after they start, so their theme is set.
+     */
+    private startThemeSync;
+    private stopThemeSync;
+    private ensureInitialized;
+    private updateCollapsed;
+    private updateHidden;
+    private updateMaximized;
+    private updateHeight;
+    private updateWidth;
+    private updateActiveTabId;
+    private findTab;
+    private patchTab;
+    /** Remove tabs without touching collapsed/initialized state. */
+    private removeTabs;
+    private releaseTab;
+    private releasePane;
+    private focusPane;
+    private anchorStyle;
+    private setTabStatus;
+    private configFields;
+    /** Resolve controlled values and derived fields on top of a snapshot. */
+    private derive;
+    private commit;
+}
+
+/**
+ * Geometry of the panel's SVG icons, shared by every framework wrapper.
+ * All icons use a 24x24 view box, `stroke="currentColor"`, round caps and
+ * joins, and no fill unless a shape says otherwise.
+ */
+interface SvgShape {
+    tag: 'polyline' | 'line' | 'rect';
+    attrs: Record<string, string>;
+}
+interface SvgIcon {
+    size: number;
+    strokeWidth: number;
+    shapes: SvgShape[];
+}
+declare const SVG_VIEW_BOX = "0 0 24 24";
+declare const SVG_COMMON_ATTRS: Record<string, string>;
+declare const TERMINAL_ICON: SvgIcon;
+declare const HIDE_TAB_TERMINAL_ICON: SvgIcon;
+declare const MAXIMIZE_ICON: SvgIcon;
+declare const RESTORE_ICON: SvgIcon;
+declare const CLOSE_ICON: SvgIcon;
+declare const HIDE_ICON: SvgIcon;
+/** Chevron that points where the panel body will go when the collapse button is pressed. */
+declare function collapseChevronIcon(position: CliPanelPosition, collapsed: boolean): SvgIcon;
+/** Chevron on the small "show CLI" tab, pointing into the page. */
+declare function hideTabChevronIcon(position: CliPanelPosition): SvgIcon;
+/** Square with a filled bar on the side the panel is docked to. */
+declare function positionIcon(position: CliPanelPosition, size?: number): SvgIcon;
+/** Attributes for the `<svg>` element of an icon. */
+declare function svgAttrs(icon: SvgIcon): Record<string, string>;
+
+/**
+ * View helpers shared by the React, Vue and Angular panels: class names,
+ * inline styles, labels and the lists the header and menus are built from.
+ */
+declare const PANEL_LABELS: {
+    readonly title: "CLI";
+    readonly showCli: "Show CLI";
+    readonly movePanel: "Move panel";
+    readonly hide: "Hide";
+    readonly maximize: "Maximize";
+    readonly restore: "Restore";
+    readonly expand: "Expand";
+    readonly collapse: "Collapse";
+    readonly close: "Close";
+    readonly newTerminal: "New terminal";
+    readonly closeTab: "Close tab";
+    readonly closePane: "Close pane";
+    readonly servicesHeader: "Background Services";
+    readonly servicesEmpty: "No services registered";
+    readonly serversHeader: "Server Connections";
+    readonly serversEmpty: "No servers configured";
+};
+declare const SERVICES_ICON = "\u2699";
+declare const UPTIME_ICON = "\u2191";
+declare const SUCCESS_ICON = "\u2713";
+declare const ERROR_ICON = "\u2717";
+declare const CLOSE_GLYPH = "\u00D7";
+declare function capitalize(value: string): string;
+declare function joinClasses(...classes: Array<string | false | null | undefined>): string;
+declare function panelWrapperClass(s: CliPanelSnapshot, extra?: string): string;
+declare function panelTabClass(s: CliPanelSnapshot, tab: CliPanelTab): string;
+/** Activity dot of a tab: running, last command failed, or idle. */
+declare function tabDotClass(status: CliPanelTabStatus | undefined): string;
+declare function panelTabDotClass(s: CliPanelSnapshot, tab: CliPanelTab): string;
+declare function panesContainerClass(s: CliPanelSnapshot): string;
+declare function paneClass(s: CliPanelSnapshot, tabId: number, paneId: number): string;
+declare function glowLineClass(s: CliPanelSnapshot): string;
+declare function positionDropdownItemClass(s: CliPanelSnapshot, position: CliPanelPosition): string;
+/** Size, visibility and theme variables of the panel wrapper. */
+declare function panelWrapperStyle(s: CliPanelSnapshot): Record<string, string>;
+declare function paneStyle(widthPercent: number): Record<string, string>;
+declare function contextMenuStyle(s: CliPanelSnapshot): Record<string, string>;
+interface PanelStatusIndicator {
+    key: 'execution' | 'services' | 'lastCommand' | 'servers' | 'uptime' | 'notification';
+    /** Extra classes on the full item (top/bottom positions). */
+    itemClass: string;
+    /** Extra classes on the compact item (left/right positions). */
+    compactClass: string;
+    /** Class of the leading dot, when the indicator shows a dot. */
+    dotClass?: string;
+    /** Glyph shown before the label, when the indicator shows an icon. */
+    icon?: string;
+    iconClass?: string;
+    label: string;
+    /** Tooltip of the compact variant. */
+    title: string;
+    /** Compact variant shows only this dot (notifications). */
+    compactDotClass?: string;
+    /** Which dropdown a click opens. */
+    dropdown?: 'services' | 'servers';
+}
+/** Items of the header status bar, in display order. */
+declare function statusIndicators(s: CliPanelSnapshot): PanelStatusIndicator[];
+interface PanelPositionOption {
+    position: CliPanelPosition;
+    label: string;
+    className: string;
+}
+declare function positionOptions(s: CliPanelSnapshot): PanelPositionOption[];
+type PanelContextMenuAction = 'rename' | 'duplicate' | 'split-right' | 'close' | 'close-others' | 'close-right' | 'close-all';
+interface PanelContextMenuItem {
+    action: PanelContextMenuAction;
+    label: string;
+    disabled: boolean;
+    destructive: boolean;
+    /** Draw a separator above this item. */
+    separatorBefore: boolean;
+}
+declare function contextMenuItems(s: CliPanelSnapshot): PanelContextMenuItem[];
+/** Run a context-menu action against the tab the menu was opened for. */
+declare function runContextMenuAction(controller: CliPanelController, action: PanelContextMenuAction): void;
+/** Enter commits, Escape cancels an inline tab rename. */
+declare function handleRenameKey(controller: CliPanelController, tabId: number, key: string, value: string): void;
+/** Width of the panes container the divider belongs to, for drag math. */
+declare function panesContainerWidth(target: EventTarget | null): number;
+interface PanelDropdownRow {
+    key: string;
+    dotClass: string;
+    name: string;
+    description?: string;
+    status: string;
+    /** Extra lines under the status (servers: API version, command count). */
+    meta: string[];
+}
+interface PanelStatusDropdown {
+    kind: 'services' | 'servers';
+    header: string;
+    emptyText: string;
+    style: Record<string, string>;
+    rows: PanelDropdownRow[];
+}
+/** The open services or servers dropdown, or null when neither is open. */
+declare function openStatusDropdown(s: CliPanelSnapshot): PanelStatusDropdown | null;
+
+export { API_VERSION, CLI_ENV_GLOBAL_PERMISSION, CLI_FRAMEWORK_SERVICE, CLOSE_GLYPH, CLOSE_ICON, CLi_Name_Art, CapturingTerminalWriter, CliAliasCommandProcessor, CliArgsParser, CliBackgroundServiceRegistry_TOKEN, CliBoot, CliBootLog, CliBootLog_TOKEN, CliCalCommandProcessor, CliCaptureCommandProcessor, CliClearCommandProcessor, CliClipboard, CliClipboardCommandProcessor, CliColorCommandProcessor, CliCommandExecutionContext, CliCommandExecutor, CliCommandHistory, CliCommandHistory_TOKEN, CliCommandProcessorRegistry, CliConfigureCommandProcessor, CliConvertCommandProcessor, CliDebugCommandProcessor, CliDefaultPingServerService, CliDiffCommandProcessor, CliDragDropService, CliEchoCommandProcessor, CliEngine, CliEnvCommandProcessor, CliEnvironment, CliEvalCommandProcessor, CliEventsCommandProcessor, CliExecutionContext, CliExecutionProcess, CliExportCommandProcessor, CliFalseCommandProcessor, CliFeedbackCommandProcessor, CliFontSizeCommandProcessor, CliFullScreenManager, CliHelpCommandProcessor, CliHistoryCommandProcessor, CliHotKeysCommandProcessor, CliHtopCommandProcessor, CliHttpClient, CliInputReader, CliJsonCommandProcessor, CliKeyValueStore, CliKeyValueStore_TOKEN, CliKillCommandProcessor, CliLogger, CliLoremCommandProcessor, CliModuleRegistry_TOKEN, CliNanoCommandProcessor, CliNotifier, CliOpenCommandProcessor, CliPackageManagerService, CliPackageManagerService_TOKEN, CliPackagesCommandProcessor, CliPanelController, CliPanelStatusTracker, CliPermissionRegistry, CliPingCommandProcessor, CliProcessRegistry, CliProcessRegistry_TOKEN, CliProcessorsRegistry_TOKEN, CliPsCommandProcessor, CliRandomCommandProcessor, CliScreenCommandProcessor, CliScriptSyntaxError, CliSeqCommandProcessor, CliServerCommandProcessor, CliServerConnection, CliServerManager, CliServerManager_TOKEN, CliServerMultiProxyProcessor, CliServerProxyProcessor, CliServiceContainer, CliServicesCommandProcessor, CliSleepCommandProcessor, CliSnippetCommandProcessor, CliSshCommandProcessor, CliStateStore, CliStateStoreManager, CliStateStoreManager_TOKEN, CliTerminalProgressBar, CliTerminalSpinner, CliTerminalTextAnimator, CliTerminalWriter, CliTestCommandProcessor, CliTestHarness, CliThemeCommandProcessor, CliTimeCommandProcessor, CliTimerManager, CliTimestampCommandProcessor, CliTrueCommandProcessor, CliUnAliasCommandProcessor, CliUnameCommandProcessor, CliUnsetCommandProcessor, CliUptimeCommandProcessor, CliVersionCommandProcessor, CliYesCommandProcessor, CommandParser, DEFAULT_GLOBAL_STATUS, DEFAULT_PANEL_HEIGHT, DEFAULT_PANEL_WIDTH, DEFAULT_TAB_STATUS, ERROR_ICON, EXEC_POLL_MS, GLOBAL_POLL_MS, HIDE_ICON, HIDE_TAB_TERMINAL_ICON, ICliEnvironment_TOKEN, ICliPingServerService_TOKEN, ICliScriptRunner_TOKEN, JsFallbackAccelerator, LIBRARY_VERSION, MAXIMIZE_ICON, MIN_PANEL_SIZE, MIN_PANE_WIDTH_PERCENT, OverlayAddon, PANEL_LABELS, PANEL_POSITIONS, ProcessExitedError, RESTORE_ICON, SERVICES_ICON, SUCCESS_ICON, SVG_COMMON_ATTRS, SVG_VIEW_BOX, ScriptLoaderService, SyntaxHighlighterRegistry_TOKEN, TERMINAL_ICON, UPTIME_ICON, appendOutputToFile, appendStderrToFile, applyEnvironmentChange, builtinProcessors, capitalize, clampPanelSize, cliScriptRunner, collapseChevronIcon, computeDiff, computeGlobalStatus, computeTabStatus, contextGlobalParameter, contextMenuItems, contextMenuStyle, createCliEngine, createServerModule, defaultFontSize, describeShellClose, distributePaneWidths, dropdownAnchorStyle, executeOnServer, expandBraces, expandEnvironmentVars, expandGlobs, formatDiff, formatUptime, getAccelerator, getCliNameArt, getGreetingBasedOnTime, getTerminalOptions, glowLineClass, greetingModule, groupBy, handleRenameKey, helpGlobalParameter, hideTabChevronIcon, hotkeysInfo, initWasmAccelerator, initializeServices, initializeTerminal, isHorizontalPosition, isWasmAccelerated, joinClasses, matchGlob, mergeCliOptions, miscProcessors, normalizePaneWidths, openLink, openStatusDropdown, paneClass, paneStyle, panelTabClass, panelTabDotClass, panelWrapperClass, panelWrapperStyle, panesContainerClass, panesContainerWidth, parseAssignments, parseScript, positionDropdownItemClass, positionIcon, positionOptions, reconcileArgs, renderServerResponse, renderSingleOutput, resizePaneWidths, resizedPanelSize, resolveCliHostConfig, runContextMenuAction, runScript, splitWords, statusIndicators, substituteCommands, substituteVars, svgAttrs, systemProcessors, tabDotClass, themeInfos, themes, tryExecuteScript, versionGlobalParameter, waitForLayout, welcomeModule, writeOutputToFile, writeStderrToFile };
+export type { AnchorRect, CdnSourceName, CliBootLogOptions, CliEngineOptions, CliEnvironmentChange, CliEnvironmentProfile, CliEnvironmentScope, CliEnvironmentSnapshot, CliEnvironmentSource, CliExecutionContextDeps, CliHostConfig, CliPanelCallbacks, CliPanelContextMenu, CliPanelControlledState, CliPanelControllerOptions, CliPanelExecutionState, CliPanelGlobalStatus, CliPanelPane, CliPanelServerDetail, CliPanelServerState, CliPanelServiceDetail, CliPanelSnapshot, CliPanelStatusTrackerListener, CliPanelTab, CliPanelTabStatus, CliPanelViewport, CliTestResult, CliWelcomeMessageConfig, CommandParserOutput, CommandPart, ConfigureState, CreateCliEngineConfig, DefaultServerProvider, DiffLine, DiffType, ICliEnvironment, ICliExecutionHost, ICliScriptRunOptions, ICliScriptRunner, ICliStateStoreManager, ICliWasmAccelerator, InitializeServicesOptions, InitializeServicesResult, MultiProxyEntry, PanelContextMenuAction, PanelContextMenuItem, PanelDropdownRow, PanelPositionOption, PanelStatusDropdown, PanelStatusIndicator, ParsedArg, ParsedToken, SvgIcon, SvgShape, TerminalSetupResult, ThemeState };