@robota-sdk/agent-transport 3.0.0-beta.64

package/src/tui/flows/permission-prompt-flow.ts

@@ -0,0 +1,76 @@
+import {
+  applySelectionInput,
+  getDirectionalSelectionInputAction,
+  type ISelectionFlowState,
+  type ISelectionInputKey,
+  type TSelectionInputAction,
+} from './selection-flow.js';
+
+export const PERMISSION_PROMPT_OPTIONS = ['Allow', 'Allow always (this session)', 'Deny'] as const;
+
+export type TPermissionPromptDecision = true | 'allow-session' | false;
+export type TPermissionPromptInputAction =
+  | TSelectionInputAction
+  | { type: 'shortcut'; index: number };
+
+export type TPermissionPromptEffect =
+  | { type: 'none' }
+  | { type: 'resolve'; decision: TPermissionPromptDecision };
+
+export function getPermissionPromptInputAction(
+  input: string,
+  key: ISelectionInputKey,
+): TPermissionPromptInputAction | undefined {
+  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
+  if (action !== undefined) {
+    return action;
+  }
+  if (input === 'y' || input === '1') {
+    return { type: 'shortcut', index: 0 };
+  }
+  if (input === 'a' || input === '2') {
+    return { type: 'shortcut', index: 1 };
+  }
+  if (input === 'n' || input === 'd' || input === '3') {
+    return { type: 'shortcut', index: 2 };
+  }
+  return undefined;
+}
+
+export function applyPermissionPromptInput(
+  state: ISelectionFlowState,
+  action: TPermissionPromptInputAction,
+): { state: ISelectionFlowState; effect: TPermissionPromptEffect } {
+  if (state.resolved) {
+    return { state, effect: { type: 'none' } };
+  }
+  if (typeof action !== 'string') {
+    return resolvePermissionIndex(state, action.index);
+  }
+  const result = applySelectionInput(state, action, {
+    itemCount: PERMISSION_PROMPT_OPTIONS.length,
+  });
+  if (result.effect.type !== 'select') {
+    return { state: result.state, effect: { type: 'none' } };
+  }
+  return {
+    state: result.state,
+    effect: { type: 'resolve', decision: getPermissionDecision(result.effect.index) },
+  };
+}
+
+export function getPermissionDecision(index: number): TPermissionPromptDecision {
+  if (index === 0) return true;
+  if (index === 1) return 'allow-session';
+  return false;
+}
+
+function resolvePermissionIndex(
+  state: ISelectionFlowState,
+  index: number,
+): { state: ISelectionFlowState; effect: TPermissionPromptEffect } {
+  return {
+    state: { ...state, selectedIndex: index, resolved: true },
+    effect: { type: 'resolve', decision: getPermissionDecision(index) },
+  };
+}

package/src/tui/flows/selection-flow.ts

@@ -0,0 +1,126 @@
+export interface ISelectionFlowState {
+  selectedIndex: number;
+  scrollOffset: number;
+  resolved: boolean;
+}
+
+export interface ISelectionInputKey {
+  escape?: boolean;
+  return?: boolean;
+  upArrow?: boolean;
+  downArrow?: boolean;
+  leftArrow?: boolean;
+  rightArrow?: boolean;
+}
+
+export type TSelectionInputAction = 'cancel' | 'select' | 'previous' | 'next';
+
+export type TSelectionEffect =
+  | { type: 'none' }
+  | { type: 'cancel' }
+  | { type: 'select'; index: number };
+
+export interface ISelectionFlowOptions {
+  itemCount: number;
+  maxVisible?: number;
+  wrap?: boolean;
+  enabled?: boolean;
+}
+
+export function createSelectionFlowState(): ISelectionFlowState {
+  return { selectedIndex: 0, scrollOffset: 0, resolved: false };
+}
+
+export function getVerticalSelectionInputAction(
+  key: ISelectionInputKey,
+): TSelectionInputAction | undefined {
+  if (key.escape === true) return 'cancel';
+  if (key.upArrow === true) return 'previous';
+  if (key.downArrow === true) return 'next';
+  if (key.return === true) return 'select';
+  return undefined;
+}
+
+export function getDirectionalSelectionInputAction(
+  key: ISelectionInputKey,
+): TSelectionInputAction | undefined {
+  if (key.escape === true) return 'cancel';
+  if (key.leftArrow === true || key.upArrow === true) return 'previous';
+  if (key.rightArrow === true || key.downArrow === true) return 'next';
+  if (key.return === true) return 'select';
+  return undefined;
+}
+
+export function applySelectionInput(
+  state: ISelectionFlowState,
+  action: TSelectionInputAction,
+  options: ISelectionFlowOptions,
+): { state: ISelectionFlowState; effect: TSelectionEffect } {
+  if (state.resolved) {
+    return { state, effect: { type: 'none' } };
+  }
+  if (action === 'cancel') {
+    return { state: { ...state, resolved: true }, effect: { type: 'cancel' } };
+  }
+  if (options.enabled === false || options.itemCount === 0) {
+    return { state, effect: { type: 'none' } };
+  }
+  if (action === 'select') {
+    const index = clampIndex(state.selectedIndex, options.itemCount);
+    return {
+      state: { ...state, selectedIndex: index, resolved: true },
+      effect: { type: 'select', index },
+    };
+  }
+  const selectedIndex = moveSelection(state.selectedIndex, action, options);
+  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
+  return { state: { ...state, selectedIndex, scrollOffset }, effect: { type: 'none' } };
+}
+
+export function normalizeSelectionState(
+  state: ISelectionFlowState,
+  options: ISelectionFlowOptions,
+): ISelectionFlowState {
+  if (options.itemCount === 0) {
+    return { ...state, selectedIndex: 0, scrollOffset: 0 };
+  }
+  const selectedIndex = clampIndex(state.selectedIndex, options.itemCount);
+  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
+  if (selectedIndex === state.selectedIndex && scrollOffset === state.scrollOffset) {
+    return state;
+  }
+  return {
+    ...state,
+    selectedIndex,
+    scrollOffset,
+  };
+}
+
+function moveSelection(
+  selectedIndex: number,
+  action: TSelectionInputAction,
+  options: ISelectionFlowOptions,
+): number {
+  if (action === 'previous') {
+    if (options.wrap === true && selectedIndex === 0) return options.itemCount - 1;
+    return Math.max(0, selectedIndex - 1);
+  }
+  if (options.wrap === true && selectedIndex === options.itemCount - 1) return 0;
+  return Math.min(options.itemCount - 1, selectedIndex + 1);
+}
+
+function resolveScrollOffset(
+  selectedIndex: number,
+  scrollOffset: number,
+  options: ISelectionFlowOptions,
+): number {
+  const maxVisible = options.maxVisible ?? options.itemCount;
+  if (maxVisible <= 0) return 0;
+  if (selectedIndex < scrollOffset) return selectedIndex;
+  if (selectedIndex >= scrollOffset + maxVisible) return selectedIndex - maxVisible + 1;
+  return Math.max(0, scrollOffset);
+}
+
+function clampIndex(index: number, itemCount: number): number {
+  return Math.min(Math.max(index, 0), itemCount - 1);
+}

package/src/tui/flows/text-prompt-flow.ts

@@ -0,0 +1,98 @@
+export interface ITextPromptFlowState {
+  value: string;
+  error?: string;
+  resolved: boolean;
+}
+
+export interface ITextPromptInputKey {
+  escape?: boolean;
+  return?: boolean;
+  backspace?: boolean;
+  delete?: boolean;
+  ctrl?: boolean;
+  meta?: boolean;
+}
+
+export type TTextPromptInputAction =
+  | { type: 'cancel' }
+  | { type: 'submit' }
+  | { type: 'delete' }
+  | { type: 'insert'; value: string };
+
+export type TTextPromptEffect =
+  | { type: 'none' }
+  | { type: 'cancel' }
+  | { type: 'submit'; value: string };
+
+export interface ITextPromptFlowOptions {
+  allowEmpty: boolean;
+  validate?: (value: string) => string | undefined;
+}
+
+export function createTextPromptFlowState(): ITextPromptFlowState {
+  return { value: '', resolved: false };
+}
+
+export function getTextPromptInputAction(
+  input: string,
+  key: ITextPromptInputKey,
+): TTextPromptInputAction | undefined {
+  if (key.escape === true) {
+    return { type: 'cancel' };
+  }
+  if (key.return === true) {
+    return { type: 'submit' };
+  }
+  if (key.backspace === true || key.delete === true) {
+    return { type: 'delete' };
+  }
+  if (input && key.ctrl !== true && key.meta !== true) {
+    return { type: 'insert', value: input };
+  }
+  return undefined;
+}
+
+export function applyTextPromptInput(
+  state: ITextPromptFlowState,
+  action: TTextPromptInputAction,
+  options: ITextPromptFlowOptions,
+): { state: ITextPromptFlowState; effect: TTextPromptEffect } {
+  if (state.resolved) {
+    return { state, effect: { type: 'none' } };
+  }
+  if (action.type === 'cancel') {
+    return { state: { ...state, resolved: true }, effect: { type: 'cancel' } };
+  }
+  if (action.type === 'delete') {
+    return {
+      state: { ...state, value: state.value.slice(0, -1), error: undefined },
+      effect: { type: 'none' },
+    };
+  }
+  if (action.type === 'insert') {
+    return {
+      state: { ...state, value: state.value + action.value, error: undefined },
+      effect: { type: 'none' },
+    };
+  }
+  return submitTextPromptValue(state, options);
+}
+
+function submitTextPromptValue(
+  state: ITextPromptFlowState,
+  options: ITextPromptFlowOptions,
+): { state: ITextPromptFlowState; effect: TTextPromptEffect } {
+  const trimmed = state.value.trim();
+  if (!trimmed && !options.allowEmpty) {
+    const emptyError = options.validate?.(trimmed);
+    return {
+      state: emptyError ? { ...state, error: emptyError } : state,
+      effect: { type: 'none' },
+    };
+  }
+  const error = options.validate?.(trimmed);
+  if (error !== undefined) {
+    return { state: { ...state, error }, effect: { type: 'none' } };
+  }
+  return { state: { ...state, resolved: true }, effect: { type: 'submit', value: trimmed } };
+}

package/src/tui/hooks/command-effect-handler.ts

@@ -0,0 +1,98 @@
+import type { TCommandEffect, TStatusLineCommandSettingsPatch } from '@robota-sdk/agent-framework';
+import { isStatusLineCommandSettingsPatch } from '@robota-sdk/agent-framework';
+import { createSystemMessage, messageToHistoryEntry } from '@robota-sdk/agent-core';
+import type { IHistoryEntry, TSessionEndReason } from '@robota-sdk/agent-core';
+import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
+
+export interface ICommandEffectHandlerDeps {
+  addEntry: (entry: IHistoryEntry) => void;
+  requestShutdown: (reason: TSessionEndReason, message: string) => void;
+  requestModelChange: (modelId: string) => void;
+  openPluginTUI: () => void;
+  openSessionPicker: () => void;
+  openTransportTUI: () => void;
+  openAgentSwitcher: () => void;
+  renameSession: (name: string) => void;
+  applyStatusLinePatch: (patch: TStatusLineCommandSettingsPatch) => boolean;
+  cliAdapter: ITuiCliAdapter;
+}
+
+export function applyCommandEffects(
+  effects: readonly TCommandEffect[],
+  deps: ICommandEffectHandlerDeps,
+): boolean {
+  for (const effect of effects) {
+    if (effect.type === 'model-change-requested') {
+      deps.requestModelChange(effect.modelId);
+      return true;
+    }
+    if (effect.type === 'language-change-requested') {
+      applyLanguageEffect(effect.language, deps);
+      return true;
+    }
+    if (effect.type === 'settings-reset-requested') {
+      applySettingsResetEffect(deps);
+      return true;
+    }
+    if (effect.type === 'session-exit-requested') {
+      deps.requestShutdown(
+        effect.reason ?? 'prompt_input_exit',
+        effect.message ?? 'User requested exit',
+      );
+      return true;
+    }
+    if (effect.type === 'session-restart-requested') {
+      deps.requestShutdown(effect.reason, effect.message);
+      return true;
+    }
+    if (effect.type === 'plugin-tui-requested') {
+      deps.openPluginTUI();
+      return true;
+    }
+    if (effect.type === 'settings-tui-requested') {
+      deps.openTransportTUI();
+      return true;
+    }
+    if (effect.type === 'agent-switcher-requested') {
+      deps.openAgentSwitcher();
+      return true;
+    }
+    if (effect.type === 'session-picker-requested') {
+      deps.openSessionPicker();
+      return true;
+    }
+    if (effect.type === 'session-renamed') {
+      deps.renameSession(effect.name);
+      return true;
+    }
+    if (effect.type === 'statusline-settings-patch') {
+      if (isStatusLineCommandSettingsPatch(effect.patch)) {
+        return deps.applyStatusLinePatch(effect.patch);
+      }
+    }
+  }
+  return false;
+}
+
+function applyLanguageEffect(language: string, deps: ICommandEffectHandlerDeps): void {
+  const settingsPath = deps.cliAdapter.getUserSettingsPath();
+  const settings = deps.cliAdapter.readSettings(settingsPath);
+  settings.language = language;
+  deps.cliAdapter.writeSettings(settingsPath, settings);
+  deps.addEntry(
+    messageToHistoryEntry(createSystemMessage(`Language set to "${language}". Restarting...`)),
+  );
+  deps.requestShutdown('other', 'Language change restart');
+}
+
+function applySettingsResetEffect(deps: ICommandEffectHandlerDeps): void {
+  const settingsPath = deps.cliAdapter.getUserSettingsPath();
+  if (deps.cliAdapter.deleteSettings(settingsPath)) {
+    deps.addEntry(
+      messageToHistoryEntry(createSystemMessage(`Deleted ${settingsPath}. Exiting...`)),
+    );
+  } else {
+    deps.addEntry(messageToHistoryEntry(createSystemMessage('No user settings found.')));
+  }
+  deps.requestShutdown('other', 'Reset settings restart');
+}

package/src/tui/hooks/command-effect-queue.ts

@@ -0,0 +1,39 @@
+import type { ICommandInteraction, TCommandEffect } from '@robota-sdk/agent-framework';
+
+export type TQueuedCommandState =
+  | {
+      type: 'interaction';
+      interaction: ICommandInteraction;
+    }
+  | {
+      type: 'effects';
+      effects: readonly TCommandEffect[];
+    };
+
+export interface ICommandEffectQueue {
+  enqueueInteraction(interaction: ICommandInteraction): void;
+  enqueueEffects(effects: readonly TCommandEffect[]): void;
+  drain(): TQueuedCommandState | undefined;
+  clear(): void;
+}
+
+export class CommandEffectQueue implements ICommandEffectQueue {
+  private readonly queue: TQueuedCommandState[] = [];
+
+  enqueueInteraction(interaction: ICommandInteraction): void {
+    this.queue.push({ type: 'interaction', interaction });
+  }
+
+  enqueueEffects(effects: readonly TCommandEffect[]): void {
+    if (effects.length === 0) return;
+    this.queue.push({ type: 'effects', effects: [...effects] });
+  }
+
+  drain(): TQueuedCommandState | undefined {
+    return this.queue.shift();
+  }
+
+  clear(): void {
+    this.queue.length = 0;
+  }
+}

package/src/tui/hooks/model-change-side-effect.ts

@@ -0,0 +1,63 @@
+import {
+  createSystemMessage,
+  getModelName,
+  messageToHistoryEntry,
+  type IHistoryEntry,
+  type TSessionEndReason,
+} from '@robota-sdk/agent-core';
+
+type TApplyModelChange = (
+  cwd: string,
+  modelId: string,
+  options?: { providerOverride?: string },
+) => { applied: boolean };
+
+export interface IApplyConfirmedModelChangeDeps {
+  cwd: string;
+  modelId: string;
+  providerOverride?: string | undefined;
+  addEntry: (entry: IHistoryEntry) => void;
+  requestShutdown: (reason: TSessionEndReason, message: string) => void;
+  applyModelChange?: TApplyModelChange;
+}
+
+export function formatModelChangeConfirmationMessage(modelId: string): string {
+  return `Change model to ${getModelName(modelId)}? This will exit the current session so the next session uses it.`;
+}
+
+export function formatModelChangeExitMessage(modelId: string): string {
+  return `Model changed to ${getModelName(modelId)}. Exiting so the next session uses it.`;
+}
+
+export function applyConfirmedModelChange(deps: IApplyConfirmedModelChangeDeps): void {
+  const applyModelChange = deps.applyModelChange;
+  if (!applyModelChange) {
+    deps.addEntry(
+      messageToHistoryEntry(createSystemMessage('Model change unavailable: no adapter provided.')),
+    );
+    return;
+  }
+
+  const options =
+    deps.providerOverride !== undefined ? { providerOverride: deps.providerOverride } : undefined;
+
+  try {
+    // allow-fallback: user-facing error display for model change failure
+    applyModelChange(deps.cwd, deps.modelId, options);
+    deps.addEntry(
+      messageToHistoryEntry(createSystemMessage(formatModelChangeExitMessage(deps.modelId))),
+    );
+    deps.requestShutdown('other', 'Model change applied');
+  } catch (error) {
+    // allow-fallback: user-facing error display for model change failure
+    deps.addEntry(
+      messageToHistoryEntry(
+        createSystemMessage(`Failed: ${error instanceof Error ? error.message : String(error)}`),
+      ),
+    );
+  }
+}
+
+export function addModelChangeCancelledMessage(addEntry: (entry: IHistoryEntry) => void): void {
+  addEntry(messageToHistoryEntry(createSystemMessage('Model change cancelled.')));
+}

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

@@ -0,0 +1,38 @@
+import type { IHistoryEntry } from '@robota-sdk/agent-core';
+import type { InteractiveSession } from '@robota-sdk/agent-framework';
+import type {
+  TCommandInteractionPrompt as TInteractivePrompt,
+  IStatusLineCommandSettings as TStatusLineSettings,
+} from '@robota-sdk/agent-framework';
+import type { ICommandEffectQueue } from './command-effect-queue.js';
+
+export type { TInteractivePrompt, TStatusLineSettings };
+
+export interface IUseSideEffectsOptions {
+  cwd: string;
+  providerOverride?: string | undefined;
+  interactiveSession: InteractiveSession;
+  commandEffectQueue: ICommandEffectQueue;
+  addEntry: (entry: IHistoryEntry) => void;
+  baseHandleSubmit: (input: string) => Promise<void>;
+  setSessionName: (name: string) => void;
+  setStatusLineSettings: (settings: TStatusLineSettings) => void;
+  showSessionPickerOnStart?: boolean;
+  openAgentSwitcher?: () => void;
+}
+
+export interface IUseSideEffectsResult {
+  handleSubmit: (input: string) => Promise<void>;
+  pendingModelId: string | null;
+  pendingInteractionPrompt: TInteractivePrompt | null;
+  showPluginTUI: boolean;
+  showSessionPicker: boolean;
+  showTransportTUI: boolean;
+  setPendingModelId: (id: string | null) => void;
+  setShowPluginTUI: (show: boolean) => void;
+  setShowSessionPicker: (show: boolean) => void;
+  setShowTransportTUI: (show: boolean) => void;
+  handleModelConfirm: (index: number) => void;
+  handleInteractionSubmit: (value: string) => Promise<void>;
+  handleInteractionCancel: () => void;
+}

package/src/tui/hooks/use-interactive-session-init.ts

@@ -0,0 +1,50 @@
+import { InteractiveSession, CommandRegistry } from '@robota-sdk/agent-framework';
+import type { TToolArgs } from '@robota-sdk/agent-core';
+import type { TPermissionResultValue } from '@robota-sdk/agent-framework';
+import { TuiStateManager } from '../tui-state-manager.js';
+import { CommandEffectQueue, type ICommandEffectQueue } from './command-effect-queue.js';
+import type { IInteractiveSessionProps } from './useInteractiveSession.js';
+
+export interface IInitState {
+  interactiveSession: InteractiveSession;
+  registry: CommandRegistry;
+  commandEffectQueue: ICommandEffectQueue;
+  manager: TuiStateManager;
+}
+
+export function initializeSession(
+  props: IInteractiveSessionProps,
+  permissionHandler: (toolName: string, toolArgs: TToolArgs) => Promise<TPermissionResultValue>,
+): IInitState {
+  const interactiveSession = new InteractiveSession({
+    cwd: props.cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    permissionHandler,
+    sessionStore: props.sessionStore,
+    resumeSessionId: props.resumeSessionId,
+    forkSession: props.forkSession,
+    sessionName: props.sessionName,
+    backgroundTaskRunners: props.backgroundTaskRunners,
+    subagentRunnerFactory: props.subagentRunnerFactory,
+    commandModules: props.commandModules,
+    commandHostAdapters: props.commandHostAdapters,
+    shellExec: props.shellExec,
+    language: props.language,
+    agentName: props.agentName,
+  });
+
+  const registry = new CommandRegistry();
+  for (const module of props.commandModules ?? []) {
+    registry.addModule(module);
+  }
+  props.reloadPluginCommandSource?.(registry);
+
+  return {
+    interactiveSession,
+    registry,
+    manager: new TuiStateManager(),
+    commandEffectQueue: new CommandEffectQueue(),
+  };
+}

package/src/tui/hooks/useAutocomplete.ts

@@ -0,0 +1,85 @@
+/**
+ * Slash command autocomplete hook.
+ * Extracted from InputArea.tsx for single-responsibility.
+ */
+
+import React, { useState, useMemo } from 'react';
+import type { CommandRegistry, ICommand } from '@robota-sdk/agent-framework';
+
+/** Parse input to determine autocomplete state */
+export function parseSlashInput(value: string): {
+  isSlash: boolean;
+  parentCommand: string;
+  filter: string;
+} {
+  if (!value.startsWith('/')) return { isSlash: false, parentCommand: '', filter: '' };
+  const afterSlash = value.slice(1);
+  const spaceIndex = afterSlash.indexOf(' ');
+  if (spaceIndex === -1) return { isSlash: true, parentCommand: '', filter: afterSlash };
+  const parent = afterSlash.slice(0, spaceIndex);
+  const rest = afterSlash.slice(spaceIndex + 1);
+  return { isSlash: true, parentCommand: parent, filter: rest };
+}
+
+/** Hook: manage autocomplete state */
+export function useAutocomplete(
+  value: string,
+  registry: CommandRegistry | undefined,
+): {
+  showPopup: boolean;
+  filteredCommands: ICommand[];
+  selectedIndex: number;
+  setSelectedIndex: React.Dispatch<React.SetStateAction<number>>;
+  isSubcommandMode: boolean;
+  setShowPopup: React.Dispatch<React.SetStateAction<boolean>>;
+} {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [dismissed, setDismissed] = useState(false);
+
+  // Reset dismissed when input changes
+  const prevValueRef = React.useRef(value);
+  if (prevValueRef.current !== value) {
+    prevValueRef.current = value;
+    if (dismissed) setDismissed(false);
+  }
+
+  const parsed = parseSlashInput(value);
+  const isSubcommandMode = parsed.isSlash && parsed.parentCommand.length > 0;
+
+  const filteredCommands = useMemo(() => {
+    if (!registry || !parsed.isSlash || dismissed) return [];
+    if (isSubcommandMode) {
+      const subs = registry.getSubcommands(parsed.parentCommand);
+      if (subs.length === 0) return [];
+      if (!parsed.filter) return subs;
+      const lower = parsed.filter.toLowerCase();
+      return subs.filter((c) => c.name.toLowerCase().startsWith(lower));
+    }
+    return registry.getCommands(parsed.filter);
+  }, [registry, parsed.isSlash, parsed.parentCommand, parsed.filter, dismissed, isSubcommandMode]);
+
+  const showPopup = parsed.isSlash && filteredCommands.length > 0 && !dismissed;
+
+  // Clamp selectedIndex
+  if (selectedIndex >= filteredCommands.length && filteredCommands.length > 0) {
+    setSelectedIndex(filteredCommands.length - 1);
+  }
+
+  return {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup: (val) => {
+      if (typeof val === 'function') {
+        setDismissed((prev) => {
+          const nextVal = (val as (prev: boolean) => boolean)(!prev);
+          return !nextVal;
+        });
+      } else {
+        setDismissed(!val);
+      }
+    },
+  };
+}