@robota-sdk/agent-ui-terminal 3.0.0-beta.81

package/src/hooks/__tests__/use-tui-channel-stability.test.tsx

@@ -0,0 +1,100 @@
+/**
+ * SCREEN-014 regression: the workspace callbacks must keep a stable identity across re-renders.
+ *
+ * A fresh `readExecutionWorkspaceDetail` closure every render made App's detail-loading `useEffect`
+ * re-run on every render and `setState`-loop ("Maximum update depth exceeded") the moment a
+ * background entry was selected. This test pins the callbacks to a stable identity.
+ */
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, expect, it } from 'vitest';
+
+import { useTuiChannel } from '../useTuiChannel.js';
+
+import type { ITuiAppChannelPort } from '../../tui-app-channel-port.js';
+
+function makeFakeChannel(): ITuiAppChannelPort & { emitChange: () => void } {
+  const manager = {
+    history: [],
+    streamingText: '',
+    activeTools: [],
+    isThinking: false,
+    isAborting: false,
+    pendingPrompt: null,
+    executionWorkspaceSnapshot: null,
+    selectedExecutionEntryId: undefined,
+    contextState: { percentage: 0, usedTokens: 0, maxTokens: 100_000 },
+    addEntry: () => undefined,
+  };
+  let onChange: (() => void) | null = null;
+  return {
+    terminalHandoffController: undefined,
+    sessionName: undefined,
+    start: () => Promise.resolve(),
+    stop: () => Promise.resolve(),
+    subscribe: (handler) => {
+      onChange = handler;
+      return () => {
+        if (onChange === handler) onChange = null;
+      };
+    },
+    emitChange: () => onChange?.(),
+    getSnapshot: () => ({
+      ...manager,
+      lastErrorMessage: null,
+      isStalled: false,
+      sessionEventNotices: [],
+      isShuttingDown: false,
+      pendingCount: 0,
+      permissionRequest: null,
+      pendingUserAction: null,
+    }),
+    getSessionUiEventPort: () => ({ on: () => undefined, off: () => undefined }),
+    getCommandQueryPort: () => ({ getCommands: () => [], getSubcommands: () => [] }),
+    getRuntimeStatusSnapshot: (permissionMode) => ({ permissionMode, sessionId: '' }),
+    addEntry: manager.addEntry,
+    handleInput: () => Promise.resolve(),
+    abort: () => undefined,
+    cancelQueue: () => undefined,
+    stopWaitingSelfPacedLoop: () => Promise.resolve(),
+    shutdown: () => Promise.resolve(),
+    selectExecutionWorkspaceEntry: () => undefined,
+    readExecutionWorkspaceDetail: () => Promise.resolve({ entryId: 'x', records: [] }),
+    sendAgentJob: () => Promise.resolve(),
+    resolveUserAction: () => undefined,
+  };
+}
+
+async function tick(ms = 25): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe('useTuiChannel callback stability (SCREEN-014 regression)', () => {
+  it('keeps readExecutionWorkspaceDetail + selectExecutionWorkspaceEntry stable across re-renders', async () => {
+    const channel = makeFakeChannel();
+    const seen: Array<{ read: unknown; select: unknown }> = [];
+
+    function Probe(): React.ReactElement | null {
+      const state = useTuiChannel(channel);
+      seen.push({
+        read: state.readExecutionWorkspaceDetail,
+        select: state.selectExecutionWorkspaceEntry,
+      });
+      return null;
+    }
+
+    render(<Probe />);
+    await tick();
+
+    // Force a re-render the way the channel does on every state change.
+    channel.emitChange();
+    channel.emitChange();
+    await tick();
+
+    expect(seen.length).toBeGreaterThanOrEqual(2);
+    const first = seen[0]!;
+    const last = seen[seen.length - 1]!;
+    expect(last.read).toBe(first.read);
+    expect(last.select).toBe(first.select);
+  });
+});

package/src/hooks/__tests__/useAppThemeState.test.tsx

@@ -0,0 +1,130 @@
+/**
+ * SCREEN-2002 TC-10 — what the picker submits.
+ *
+ * The picker does not write. It submits a `/theme` line, so the HOST stays the only writer of the
+ * settings document. What it submits therefore matters: sending all three keys every time would
+ * report "syntax highlighting on, motion on" as APPLIED to a user who touched neither, and on a run
+ * with a reduced-motion flag it would drag out the pinned-for-this-run notice for a setting they
+ * never asked about.
+ */
+import { render } from 'ink-testing-library';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { useAppThemeState } from '../useAppThemeState.js';
+
+import type { IThemeToggles } from '../useAppThemeState.js';
+import type { IAppearanceSettings } from '@robota-sdk/agent-interface-command';
+
+const PERSISTED: IAppearanceSettings = {
+  theme: 'dark',
+  syntaxHighlighting: true,
+  reducedMotion: false,
+};
+
+/** Drive the hook and capture what `select` submits. */
+function submissionOf(toggles: IThemeToggles, appearance: IAppearanceSettings = PERSISTED): string {
+  const submit = vi.fn();
+  function Harness(): React.ReactElement {
+    const theme = useAppThemeState({
+      appearance,
+      visible: true,
+      setVisible: vi.fn(),
+      submit,
+    });
+    // One shot: a ref rather than an empty dependency array, so the intent is in the code instead
+    // of in a lint suppression for a rule this repo does not configure.
+    const fired = React.useRef(false);
+    React.useEffect(() => {
+      if (fired.current) return;
+      fired.current = true;
+      theme.picker.select('light', toggles);
+    });
+    return <></>;
+  }
+  render(<Harness />);
+  expect(submit).toHaveBeenCalledTimes(1);
+  return submit.mock.calls[0]?.[0] as string;
+}
+
+/**
+ * The middle link. `createThemeSurface` is tested at the producer end and `ThemePicker` at the
+ * consumer end with an injected value — so deleting these three lines left the whole suite green,
+ * which is the same both-ends-pinned-middle-severed shape that made the pin dead wiring one round
+ * earlier, one hop further in.
+ */
+describe('the motion pin reaches the picker (SCREEN-2002 TC-08)', () => {
+  function pinSeenBy(
+    reducedMotionOverride?: 'flag' | 'environment' | 'screen-reader',
+    reducedMotion?: boolean,
+  ): { tier: string; reducedMotion: boolean } | undefined {
+    let seen: { tier: string; reducedMotion: boolean } | undefined;
+    function Harness(): React.ReactElement {
+      const theme = useAppThemeState({
+        appearance: PERSISTED,
+        ...(reducedMotionOverride === undefined ? {} : { reducedMotionOverride }),
+        ...(reducedMotion === undefined ? {} : { reducedMotion }),
+        visible: true,
+        setVisible: vi.fn(),
+        submit: vi.fn(),
+      });
+      seen = theme.picker.reducedMotionPin;
+      return <></>;
+    }
+    render(<Harness />);
+    return seen;
+  }
+
+  it('carries the tier AND what it pinned, which is not what is persisted', () => {
+    // The persisted value is `false`. A run pinned to `true` must report `true` — reading the
+    // persisted half here is the contradiction the pair exists to stop, and asserting only the
+    // tier leaves that rewrite green.
+    expect(PERSISTED.reducedMotion).toBe(false);
+    expect(pinSeenBy('flag', true)).toEqual({ tier: 'flag', reducedMotion: true });
+    // `--no-reduced-motion` over a persisted `true` is the opposite direction, which a tier alone
+    // cannot tell apart.
+    expect(pinSeenBy('environment', false)).toEqual({
+      tier: 'environment',
+      reducedMotion: false,
+    });
+  });
+
+  it('reports no pin at all when a caller supplies a tier without what it pinned', () => {
+    // Both halves or neither: pairing the tier with the PERSISTED value would name a direction the
+    // run may not have taken.
+    expect(pinSeenBy('flag')).toBeUndefined();
+  });
+
+  it('leaves it absent when the settings decided', () => {
+    expect(pinSeenBy()).toBeUndefined();
+  });
+});
+
+describe('what the picker submits (SCREEN-2002 TC-10)', () => {
+  it('sends the theme ALONE when neither toggle was touched', () => {
+    expect(submissionOf({ syntaxHighlighting: true, reducedMotion: false })).toBe('/theme light');
+  });
+
+  it('adds only the toggle that changed', () => {
+    expect(submissionOf({ syntaxHighlighting: false, reducedMotion: false })).toBe(
+      '/theme light syntax off',
+    );
+    expect(submissionOf({ syntaxHighlighting: true, reducedMotion: true })).toBe(
+      '/theme light motion off',
+    );
+  });
+
+  it('sends both when both changed, as ONE line — one patch, not three', () => {
+    expect(submissionOf({ syntaxHighlighting: false, reducedMotion: true })).toBe(
+      '/theme light syntax off motion off',
+    );
+  });
+
+  it('speaks the command s vocabulary: `motion on` means reducedMotion FALSE', () => {
+    const stillByDefault = { ...PERSISTED, reducedMotion: true };
+
+    expect(submissionOf({ syntaxHighlighting: true, reducedMotion: false }, stillByDefault)).toBe(
+      '/theme light motion on',
+    );
+  });
+});

package/src/hooks/command-result-handler.ts

@@ -0,0 +1,44 @@
+/**
+ * Renders a system-command result into the TUI state (CMD-004 Phase 2).
+ *
+ * Pure rendering only: host actions were already executed (and consumed) by the session layer,
+ * screen navigation arrives via the requester-routed `ui_intent` session event (`useSideEffects`),
+ * and state-change notifications arrive as broadcast session events (`session_renamed`,
+ * `history_cleared` — bound in `TuiInteractionChannel`). The only result-carried hint consumed
+ * here is `data.pluginRegistryReloaded` — the requester-local command-registry/autocomplete
+ * refresh (the semantic plugin reload already ran host-side inside the command).
+ */
+
+import { createSystemMessage, messageToHistoryEntry } from '@robota-sdk/agent-core';
+
+import type { TuiStateManager } from '../tui-state-manager.js';
+import type { CommandRegistry } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+import type {
+  ISessionConversationRead,
+  ISessionLifecycle,
+} from '@robota-sdk/agent-interface-session';
+
+export interface ICommandResultSession extends ISessionLifecycle, ISessionConversationRead {}
+
+export function applySystemCommandResult(
+  result: ICommandResult,
+  interactiveSession: ICommandResultSession,
+  registry: CommandRegistry,
+  manager: TuiStateManager,
+  reloadPluginCommandSource?: (registry: CommandRegistry) => void,
+): void {
+  if (result.data?.['pluginRegistryReloaded'] === true) {
+    reloadPluginCommandSource?.(registry);
+  }
+  manager.addEntry(messageToHistoryEntry(createSystemMessage(result.message)));
+
+  if (interactiveSession.isInitialized) {
+    const ctx = interactiveSession.getContextState();
+    manager.setContextState({
+      percentage: ctx.usedPercentage,
+      usedTokens: ctx.usedTokens,
+      maxTokens: ctx.maxTokens,
+    });
+  }
+}

package/src/hooks/side-effects-types.ts

@@ -0,0 +1,45 @@
+import type { ITuiSessionUiEventPort } from '../tui-app-channel-port.js';
+import type { IStatusLineCommandSettings as TStatusLineSettings } from '@robota-sdk/agent-interface-command';
+
+export type { TStatusLineSettings };
+
+/**
+ * CMD-004 Phase 2 Stage C: the TUI is a pure renderer. This hook only manages the UI screens
+ * (driven by the requester-routed `ui_intent` session event), reflects the broadcast
+ * `session_renamed` title, and refreshes the statusline display after a command result — it
+ * executes no command semantics (the session layer applies host actions before the result returns).
+ */
+export interface IUseSideEffectsOptions {
+  uiEventPort: ITuiSessionUiEventPort;
+  baseHandleSubmit: (input: string) => Promise<void>;
+  /** Reflect the host-executed rename (broadcast `session_renamed`) into the rendered title. */
+  setSessionName: (name: string) => void;
+  /** Re-read the persisted statusline settings (the HOST applied any patch) — refresh-on-result. */
+  refreshStatusLineSettings: () => void;
+  /**
+   * SCREEN-2002: re-read the persisted appearance the same way. A `/theme` result has already been
+   * applied to the settings document by the host, so the live theme changes when this fires — which
+   * is what makes a theme switch take effect without a restart.
+   */
+  refreshAppearanceSettings: () => void;
+  showSessionPickerOnStart?: boolean;
+  openAgentSwitcher?: () => void;
+  /**
+   * CLI-1994: honour a `switch-session` UI intent — point this terminal at another persisted
+   * session (a fork being attached to). The surface's existing session-switch path: a new channel
+   * from the factory with the previous one stopped first. A view switch, never a merge.
+   */
+}
+
+export interface IUseSideEffectsResult {
+  handleSubmit: (input: string) => Promise<void>;
+  showPluginTUI: boolean;
+  showSessionPicker: boolean;
+  showTransportTUI: boolean;
+  /** SCREEN-2002: the theme picker, opened by the `show-theme-picker` intent. */
+  showThemePicker: boolean;
+  setShowPluginTUI: (show: boolean) => void;
+  setShowSessionPicker: (show: boolean) => void;
+  setShowTransportTUI: (show: boolean) => void;
+  setShowThemePicker: (show: boolean) => void;
+}

package/src/hooks/useAppController.ts

@@ -0,0 +1,267 @@
+import { useCallback, useMemo, useState } from 'react';
+
+import { buildStaticItems } from '../app-static-items.js';
+import { useAppInteractionState } from './useAppInteractionState.js';
+import { useAppLifecycleState } from './useAppLifecycleState.js';
+import { useAppScreenState } from './useAppScreenState.js';
+import { useAppThemeState } from './useAppThemeState.js';
+import { useTuiChannel } from './useTuiChannel.js';
+
+import type { IBuildStaticItemsInputs } from '../app-static-items.js';
+import type { IAppInputViewModel, IAppStatusViewModel, IAppViewModel } from '../app-view-model.js';
+import type { ITuiAppChannelPort, ITuiRuntimeStatusSnapshot } from '../tui-app-channel-port.js';
+import type { IAppInteractionState } from './useAppInteractionState.js';
+import type { IAppLifecycleState } from './useAppLifecycleState.js';
+import type { IAppScreenState } from './useAppScreenState.js';
+import type { IAppThemeViewModel } from './useAppThemeState.js';
+import type { ITuiChannelState } from './useTuiChannel.js';
+import type { IThemeRegistry } from '../theme/theme-registry.js';
+import type { TPermissionMode } from '@robota-sdk/agent-core';
+import type { TReducedMotionOverride } from '@robota-sdk/agent-interface-command';
+import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-command';
+import type { IInteractiveSessionStore } from '@robota-sdk/agent-interface-session';
+import type { IPromptHistorySource } from '@robota-sdk/agent-interface-session';
+import type { ITransportRegistryView } from '@robota-sdk/agent-interface-transport';
+
+export interface IUseAppControllerOptions {
+  cwd: string;
+  providerType?: string | undefined;
+  modelId?: string;
+  permissionMode?: TPermissionMode;
+  version?: string;
+  sessionStore?: IInteractiveSessionStore;
+  showSessionPickerOnStart?: boolean;
+  /** FLOW-2006: a deep link's prefill, handed to the composer exactly once. */
+  initialInput?: string;
+  initialInputOrigin?: 'external-link';
+  startupUpdateNotice?: Promise<string | undefined>;
+  transportRegistry?: ITransportRegistryView;
+  pluginAdapter?: ICommandPluginAdapter;
+  sessionSwitchError?: string;
+  sessionSwitchPending?: boolean;
+  channel: ITuiAppChannelPort;
+  onSessionSwitch: (sessionId: string) => Promise<void>;
+  onRetrySessionSwitch: () => void;
+  /** SCREEN-1993: the stored-prompt source and this run's project key; both or neither. */
+  promptHistorySource?: IPromptHistorySource;
+  promptHistoryProject?: string;
+  /** SCREEN-2002: the catalogue this surface renders from; absent ⇒ the built-ins. */
+  themeRegistry?: IThemeRegistry;
+  /** SCREEN-2002: reduced motion as the product shell resolved it (settings ← env ← flag). */
+  reducedMotion?: boolean | undefined;
+  /** SCREEN-2002: which tier decided it, when that was not the settings. */
+  reducedMotionOverride?: TReducedMotionOverride | undefined;
+}
+
+interface ICoordinationState {
+  readonly error: string | undefined;
+  readonly pending: boolean;
+  readonly blocked: boolean;
+}
+
+interface IComposition {
+  readonly props: IUseAppControllerOptions;
+  readonly state: ITuiChannelState;
+  readonly lifecycle: IAppLifecycleState;
+  readonly shell: IAppScreenState;
+  readonly interaction: IAppInteractionState;
+  readonly staticItems: IAppViewModel['staticItems'];
+  readonly runtime: ITuiRuntimeStatusSnapshot;
+  readonly coordination: ICoordinationState;
+  readonly theme: IAppThemeViewModel;
+}
+
+function getCoordinationState(
+  props: IUseAppControllerOptions,
+  lifecycle: IAppLifecycleState,
+): ICoordinationState {
+  const error = props.sessionSwitchError ?? lifecycle.startError;
+  const pending = Boolean(props.sessionSwitchPending || lifecycle.startPending);
+  return { error, pending, blocked: error !== undefined || pending };
+}
+
+function buildHistorySearch(composition: IComposition): IAppInputViewModel['historySearch'] {
+  const { promptHistorySource, promptHistoryProject } = composition.props;
+  if (promptHistorySource === undefined || promptHistoryProject === undefined) return undefined;
+  return {
+    source: promptHistorySource,
+    project: promptHistoryProject,
+    sessionId: composition.runtime.sessionId,
+    onOpenChange: composition.shell.setHistorySearchOpen,
+  };
+}
+
+function buildInput(composition: IComposition): IAppInputViewModel {
+  const { screens, workspace } = composition.shell;
+  const state = composition.state;
+  const overlayOpen = Boolean(
+    state.permissionRequest ||
+    state.pendingUserAction ||
+    screens.showPluginTUI ||
+    screens.showTransportTUI ||
+    screens.showSessionPicker ||
+    screens.showThemePicker ||
+    workspace.background.switcherVisible,
+  );
+  const interactionBlocked =
+    composition.coordination.blocked ||
+    overlayOpen ||
+    state.isShuttingDown ||
+    !workspace.isSelectedEntryInteractive ||
+    workspace.isBackgroundListFocused;
+  return {
+    submit: composition.interaction.submission.submit,
+    cancelQueue: state.handleCancelQueue,
+    disabled: interactionBlocked || (state.isThinking && state.pendingPrompt !== null),
+    queueCancellationDisabled: interactionBlocked,
+    isAborting: state.isAborting,
+    pendingPrompt: state.pendingPrompt,
+    pendingCount: state.pendingCount,
+    commandQueryPort: state.commandQueryPort,
+    sessionName: composition.lifecycle.sessionName,
+    history: state.history,
+    focusBackgroundList: workspace.focusBackgroundList,
+    historySearch: buildHistorySearch(composition),
+  };
+}
+
+function buildStatus(composition: IComposition): IAppStatusViewModel {
+  const { props, runtime, state } = composition;
+  const workspace = composition.shell.workspace;
+  return {
+    cwd: props.cwd,
+    permissionMode: runtime.permissionMode,
+    modelId: props.modelId,
+    providerType: props.providerType,
+    sessionId: runtime.sessionId,
+    isThinking: state.isThinking,
+    activeToolCount: state.activeTools.length,
+    activeBackgroundTaskCount: workspace.activeBackgroundTaskCount,
+    hasPendingPrompt: state.pendingPrompt !== null,
+    contextState: state.contextState,
+    sessionName: composition.lifecycle.sessionName,
+    settings: composition.shell.statusSettings,
+    activeAgentLabel: workspace.activeAgentLabel,
+    activePresetId: runtime.activePresetId,
+    effort: runtime.effort,
+    gitRefreshToken: composition.interaction.submission.gitRefreshToken,
+  };
+}
+
+function buildViewModel(composition: IComposition): IAppViewModel {
+  const { interaction, lifecycle, shell, state } = composition;
+  return {
+    staticItems: composition.staticItems,
+    handoffSuspended: lifecycle.handoffSuspended,
+    updateNotice: lifecycle.updateNotice,
+    coordinationError: composition.coordination.error,
+    coordinationPending: composition.coordination.pending,
+    sessionEventNotices: state.sessionEventNotices,
+    isShuttingDown: state.isShuttingDown,
+    stream: {
+      text: state.streamingText,
+      activeTools: state.activeTools,
+      isThinking: state.isThinking,
+      isStalled: state.isStalled,
+      lastErrorMessage: state.lastErrorMessage,
+    },
+    background: shell.workspace.background,
+    permissionRequest: state.permissionRequest,
+    pendingUserAction: state.pendingUserAction,
+    resolveUserAction: state.resolveUserAction,
+    ...interaction.overlays,
+    theme: composition.theme,
+    contextPercentage: state.contextState.percentage,
+    input: buildInput(composition),
+    status: buildStatus(composition),
+  };
+}
+
+/** The live theme and its picker, composed from the shell's persisted appearance and the shell's props. */
+function useControllerTheme(
+  props: IUseAppControllerOptions,
+  shell: IAppScreenState,
+): IAppThemeViewModel {
+  return useAppThemeState({
+    appearance: shell.appearance,
+    registry: props.themeRegistry,
+    reducedMotion: props.reducedMotion,
+    reducedMotionOverride: props.reducedMotionOverride,
+    visible: shell.screens.showThemePicker,
+    setVisible: shell.screens.setShowThemePicker,
+    submit: (input) => void shell.screens.handleSubmit(input),
+  });
+}
+
+/**
+ * FLOW-2006: the deep link's prefill is owned HERE, not by the composer's `useState` initializer.
+ * `AppPresentation` unmounts the prompt subtree while a terminal handoff is suspended, so a
+ * component-local initializer would re-seed a prompt the user had already cleared or submitted.
+ */
+function useExternalPrefill(
+  initialInput: string | undefined,
+  origin: IUseAppControllerOptions['initialInputOrigin'],
+): Pick<IAppInputViewModel, 'initialValue' | 'consumeInitialValue' | 'externalPromptOrigin'> {
+  const [initialValue, setInitialValue] = useState(initialInput);
+  const consumeInitialValue = useCallback(() => setInitialValue(undefined), []);
+  return { initialValue, consumeInitialValue, externalPromptOrigin: origin === 'external-link' };
+}
+
+/** The scrollback Ink commits once: the banner (unless suppressed) and the settled history. */
+function useStaticItems(
+  history: IBuildStaticItemsInputs['history'],
+  version: IBuildStaticItemsInputs['version'],
+  screenReader: IBuildStaticItemsInputs['screenReader'],
+): IAppViewModel['staticItems'] {
+  return useMemo(
+    () => buildStaticItems({ history, version, screenReader }),
+    [history, screenReader, version],
+  );
+}
+
+/** Compose responsibility-specific hooks into the only view model accepted by presentation. */
+export function useAppController(props: IUseAppControllerOptions): IAppViewModel {
+  const prefill = useExternalPrefill(props.initialInput, props.initialInputOrigin);
+  const state = useTuiChannel(props.channel);
+  const lifecycle = useAppLifecycleState(props.channel, props.startupUpdateNotice);
+  const coordination = getCoordinationState(props, lifecycle);
+  const shell = useAppScreenState({
+    state,
+    setSessionName: lifecycle.setSessionName,
+    sessionStore: props.sessionStore,
+    onSessionSwitch: props.onSessionSwitch,
+    showSessionPickerOnStart: props.showSessionPickerOnStart,
+    coordinationBlocked: coordination.blocked,
+  });
+  const interaction = useAppInteractionState({
+    cwd: props.cwd,
+    state,
+    shell,
+    sessionStore: props.sessionStore,
+    onSessionSwitch: props.onSessionSwitch,
+    pluginAdapter: props.pluginAdapter,
+    transportRegistry: props.transportRegistry,
+    recoveryError: coordination.error,
+    recoveryPending: coordination.pending,
+    coordinationBlocked: coordination.blocked,
+    retryRecovery:
+      props.sessionSwitchError !== undefined ? props.onRetrySessionSwitch : lifecycle.retryStart,
+  });
+  const staticItems = useStaticItems(state.history, props.version, interaction.screenReader);
+  const runtime = state.getRuntimeStatusSnapshot(props.permissionMode ?? 'default');
+  const theme = useControllerTheme(props, shell);
+  const viewModel = buildViewModel({
+    props,
+    state,
+    lifecycle,
+    shell,
+    interaction,
+    staticItems,
+    runtime,
+    coordination,
+    theme,
+  });
+  return { ...viewModel, input: { ...viewModel.input, ...prefill } };
+}
+
+export type { IAppViewModel } from '../app-view-model.js';