@abot-ai/runtime 1.7.0 → 1.8.1

package/dist/src/web-ui/app/controllers/composer-submit-controller.d.ts

@@ -1,33 +1,22 @@
-import type { ComposerScope } from "./composer-queue-controller.js";
-
-export interface ComposerSubmissionBlock {
-  code: string;
-  message: string;
-}
-
-export interface ComposerSubmitState {
-  activeRequestId: string;
-  pendingAttachments: readonly unknown[];
-  composerSending: boolean;
-  currentSessionId: string;
-  sessionViewVersion?: number;
-}
-
-export interface ComposerSubmitDom {
-  composerInput: {
-    value: string;
-    scrollHeight: number;
-    style: { height: string };
-    focus(): void;
-  };
-}
+import type { ComposerDraft } from "./composer-drafts.js";
+import type { ComposerInputSurface } from "./composer-draft-view.js";
+import type { ComposerAttachmentsController } from "./composer-attachments-controller.js";
+import type { ComposerQueueController } from "./composer-queue-controller.js";
+import type { ChatRequestController } from "./chat-request-controller.js";
+import type { ComposerSubmissionAction, ComposerSubmissionLifecycle, ComposerSubmissionResult } from "./composer-submission-lifecycle.js";
+import type { ConversationSessionState } from "./conversation-session-controller.js";
+
+export interface ComposerSubmissionBlock { code: string; message: string }
+export type ComposerSubmitState = Pick<ConversationSessionState, "activeRequestId" | "currentSessionId" | "requestLifecycles">;
+export interface ComposerSubmitDom { composerInput: ComposerInputSurface }
 
 export interface ComposerSubmitActions {
-  primaryAction(): string;
+  primaryAction(): ComposerSubmissionAction;
   render(options: {
     activeRequestId: string;
-    stopping?: boolean;
-    onStop?: () => void;
+    waitingRequestId?: string;
+    stopping: boolean;
+    onStop(): void;
     attachmentCount: number;
     busy: boolean;
     disabled: boolean;
@@ -35,49 +24,29 @@ export interface ComposerSubmitActions {
   }): void;
 }
 
-export interface ComposerSubmitAttachments {
-  activeUploadCount(): number;
-}
-
-export interface ComposerSubmitQueue {
-  enqueue(text: string): Promise<void>;
-  isCurrentDraining(): boolean;
-  queuedCount(): number;
-  restoreText(text: string, scope: ComposerScope): void;
-}
-
-export interface ComposerSubmitChatRequests {
-  sendMessage(text: string): Promise<void>;
-  stopRequest?(scope: ComposerScope & { requestId: string }): Promise<{ accepted: boolean; reason?: string }>;
-}
-
-export interface ComposerSubmitConversationSession {
-  appendRequestError(error: unknown): void;
-}
-
+export type ComposerDispatchResult = ComposerSubmissionResult | { status: "blocked"; error: unknown };
 export interface ComposerSubmitControllerOptions {
   state: ComposerSubmitState;
   dom: ComposerSubmitDom;
   composerActions: ComposerSubmitActions;
-  attachments: ComposerSubmitAttachments;
-  queue: ComposerSubmitQueue;
-  steer: (text: string) => Promise<void>;
-  chatRequests: ComposerSubmitChatRequests;
-  conversationSession: ComposerSubmitConversationSession;
-  selectedEnvironmentId: () => string;
-  setMessageStatus: (message: string, busy?: boolean) => void;
-  getSubmissionBlock?: () => ComposerSubmissionBlock | null;
-  onSubmissionBlocked?: (block: ComposerSubmissionBlock) => void;
-  isComposerVisible?: () => boolean;
+  getDraft(): ComposerDraft;
+  attachments: Pick<ComposerAttachmentsController, "activeUploadCount">;
+  queue: Pick<ComposerQueueController, "isCurrentDraining" | "queuedCount">;
+  lifecycle: Pick<ComposerSubmissionLifecycle, "hasPendingScope">;
+  submit(action: ComposerSubmissionAction): Promise<ComposerSubmissionResult>;
+  stopRequest: ChatRequestController["stopRequest"];
+  selectedEnvironmentId(): string;
+  setMessageStatus(message: string, busy?: boolean): void;
+  getSubmissionBlock?(): ComposerSubmissionBlock | null;
+  onSubmissionBlocked?(block: ComposerSubmissionBlock): void;
+  isComposerVisible?(): boolean;
+  allowsActiveRequest?: boolean;
 }
 
 export interface ComposerSubmitController {
   stop(): false | Promise<void>;
-  dispatch(requestedAction?: string): void;
+  dispatch(requestedAction?: ComposerSubmissionAction): undefined | Promise<ComposerDispatchResult>;
   resize(): void;
   updateSendState(): void;
 }
-
-export declare function createComposerSubmitController(
-  options: ComposerSubmitControllerOptions,
-): ComposerSubmitController;
+export declare function createComposerSubmitController(options: ComposerSubmitControllerOptions): ComposerSubmitController;

package/dist/src/web-ui/app/controllers/composer-submit-controller.js

@@ -1,160 +1,78 @@
-import {
-  captureComposerSubmissionScope,
-  isCurrentComposerSubmissionScope,
-} from "../lib/composer-submission-scope.js";
 import { resolveComposerPrimaryAction } from "../ui-behavior.js";
 import { createComposerStopController } from "./composer-stop-controller.js";
-import {
-  hasWaitingApproval,
-  waitingRequest,
-} from "../lib/request-lifecycle-view.js";
+import { hasWaitingApproval, waitingRequest } from "../lib/request-lifecycle-view.js";
 
+/** UI intent only. The shared submission lifecycle owns all payload transitions. */
 export function createComposerSubmitController({
-  state,
-  dom,
-  composerActions,
-  attachments,
-  queue,
-  steer,
-  chatRequests,
-  conversationSession,
-  selectedEnvironmentId,
-  setMessageStatus,
-  getSubmissionBlock = () => null,
-  onSubmissionBlocked = () => {},
-  isComposerVisible = () => true,
+  state, dom, composerActions, getDraft, attachments, queue, lifecycle, submit,
+  stopRequest, selectedEnvironmentId, setMessageStatus,
+  getSubmissionBlock = () => null, onSubmissionBlocked = () => {},
+  isComposerVisible = () => true, allowsActiveRequest = true,
 }) {
-  const stopping = createComposerStopController({
-    state,
-    selectedEnvironmentId,
-    setMessageStatus,
-    updateSendState,
-    stopRequest: (scope) => chatRequests.stopRequest(scope),
-  });
+  const stopping = createComposerStopController({ state, selectedEnvironmentId,
+    setMessageStatus, updateSendState, stopRequest });
+
   function resize() {
     if (!isComposerVisible()) return;
     dom.composerInput.style.height = "auto";
-    dom.composerInput.style.height = `${Math.min(
-      dom.composerInput.scrollHeight,
-      168,
-    )}px`;
+    dom.composerInput.style.height = `${Math.min(dom.composerInput.scrollHeight, 168)}px`;
+  }
+  function isBusy() {
+    if (lifecycle.hasPendingScope(getDraft().scope)) return true;
+    return allowsActiveRequest && queue.isCurrentDraining();
+  }
+  function cannotSubmit() {
+    if (stopping.isStopping()) return true;
+    if (allowsActiveRequest && hasWaitingApproval(state)) return true;
+    if (getSubmissionBlock()) return true;
+    if (!dom.composerInput.value.trim()) return true;
+    if (isBusy()) return true;
+    return attachments.activeUploadCount() > 0;
   }
-
   function updateSendState() {
     if (!isComposerVisible()) return;
-    const queueDraining = queue.isCurrentDraining();
-    const submissionBlock = getSubmissionBlock();
     composerActions.render({
-      activeRequestId: state.activeRequestId,
-      waitingRequestId: waitingRequest(state)?.requestId,
+      activeRequestId: allowsActiveRequest ? state.activeRequestId : "",
+      waitingRequestId: allowsActiveRequest ? waitingRequest(state)?.requestId : "",
       stopping: stopping.isStopping(),
-      onStop: () => {
-        if (isComposerVisible()) void stopping.stop();
-      },
-      attachmentCount: state.pendingAttachments.length,
-      busy: state.composerSending || queueDraining,
-      disabled:
-        stopping.isStopping() ||
-        hasWaitingApproval(state) ||
-        Boolean(submissionBlock) ||
-        !dom.composerInput.value.trim() ||
-        state.composerSending ||
-        queueDraining ||
-        attachments.activeUploadCount() > 0,
-      queuedCount: queue.queuedCount(),
+      onStop: () => { if (isComposerVisible()) void stopping.stop(); },
+      attachmentCount: getDraft().attachments.length,
+      busy: isBusy(), disabled: cannotSubmit(), queuedCount: allowsActiveRequest ? queue.queuedCount() : 0,
     });
   }
-
   function dispatch(requestedAction = "") {
     if (!isComposerVisible()) return;
-    if (stopping.isStopping()) return;
-    if (hasWaitingApproval(state)) {
-      setMessageStatus(
-        "Decide or cancel the pending approval before sending a new message.",
-      );
-      return;
-    }
-    const text = dom.composerInput.value.trim();
-    const submissionBlock = getSubmissionBlock();
-    if (text && submissionBlock) {
-      onSubmissionBlocked(submissionBlock);
-      updateSendState();
-      return;
-    }
-    if (
-      !text ||
-      state.composerSending ||
-      queue.isCurrentDraining() ||
-      attachments.activeUploadCount() > 0
-    ) {
-      return;
-    }
+    const block = getSubmissionBlock();
+    if (block) { onSubmissionBlocked(block); updateSendState(); return; }
+    if (cannotSubmit()) return;
     let action = requestedAction || composerActions.primaryAction();
-    if (state.activeRequestId && action === "send") {
-      action = resolveComposerPrimaryAction(
-        state.activeRequestId,
-        state.pendingAttachments.length,
-      );
-    }
-    const submissionScope = {
-      environmentId: selectedEnvironmentId(),
-      sessionId: state.currentSessionId,
-    };
-    state.composerSending = true;
-    setMessageStatus(
-      action === "steer"
-        ? "Sending an update to the active request."
-        : action === "send_next"
-          ? "Queueing the next message."
-          : "ABot is working.",
-      true,
-    );
-    updateSendState();
-    dom.composerInput.value = "";
+    if (!allowsActiveRequest) action = "send";
+    if (allowsActiveRequest && state.activeRequestId && action === "send")
+      action = resolveComposerPrimaryAction(state.activeRequestId, getDraft().attachments.length);
+    setMessageStatus(submissionStatus(action), true);
+    // submit synchronously takes text and files before its first await.
+    const submittedScope = getDraft().scope;
+    const operation = submit(action);
     resize();
-    const operation =
-      action === "steer"
-        ? steer(text)
-        : action === "send_next"
-          ? queue.enqueue(text)
-          : chatRequests.sendMessage(text);
-    const completionScope = captureComposerSubmissionScope(
-      state,
-      selectedEnvironmentId(),
-    );
-    const isSubmissionForCurrentComposerView = () =>
-      isCurrentComposerSubmissionScope(
-        completionScope,
-        state,
-        selectedEnvironmentId(),
-      );
-    void operation
-      .then(() => {
-        if (!isSubmissionForCurrentComposerView()) return;
-        if (action === "steer") {
-          setMessageStatus("Update accepted. ABot is working.", true);
-        } else if (action === "send_next") {
-          setMessageStatus("Message queued for this conversation.", true);
-        }
-      })
-      .catch((error) => {
-        if (!isSubmissionForCurrentComposerView()) return;
-        if (action !== "send") queue.restoreText(text, submissionScope);
-        conversationSession.appendRequestError(error);
-        setMessageStatus("ABot request failed.");
-      })
-      .finally(() => {
-        if (!isSubmissionForCurrentComposerView()) return;
-        state.composerSending = false;
-        updateSendState();
-        if (isComposerVisible()) dom.composerInput.focus();
-      });
+    updateSendState();
+    return operation.catch((error) => {
+      setMessageStatus(error.message);
+      return { status: "blocked", error };
+    }).finally(() => {
+      updateSendState();
+      if (isSameComposerScope(submittedScope, getDraft().scope) && isComposerVisible()) dom.composerInput.focus();
+    });
   }
+  return { dispatch, resize, updateSendState, stop: () => isComposerVisible() && stopping.stop() };
+}
+
+function submissionStatus(action) {
+  if (action === "steer") return "Sending an update to the active request.";
+  if (action === "send_next") return "Queueing the next message.";
+  return "ABot is working.";
+}
 
-  return {
-    dispatch,
-    resize,
-    updateSendState,
-    stop: () => isComposerVisible() && stopping.stop(),
-  };
+function isSameComposerScope(submitted, current) {
+  if (submitted.environmentId !== current.environmentId) return false;
+  return submitted.sessionId === current.sessionId;
 }

package/dist/src/web-ui/app/controllers/composer-surface-controller.js

@@ -3,6 +3,7 @@ export function createComposerSurfaceController({
   getHomeComposer,
   getChatAttachments,
   getChatSubmit,
+  refreshComposerSurfaces = () => {},
   rememberModelSelection,
   showToast,
 }) {
@@ -27,8 +28,13 @@ export function createComposerSurfaceController({
     },
     updateComposerSendState() {
       workspace.syncChatDraft();
+      refreshComposerSurfaces();
       activeSubmit()?.updateSendState();
     },
+    refreshComposerSubmissionState() {
+      getChatSubmit()?.updateSendState();
+      getHomeComposer()?.submit.updateSendState();
+    },
     resizeComposerInput() {
       activeSubmit()?.resize();
     },

package/dist/src/web-ui/app/controllers/composer-workspace-controller.d.ts

@@ -1,54 +1,36 @@
-import type {
-  ComposerAttachment,
-  ComposerAttachmentsState,
-} from "./composer-attachments-controller.js";
-import type {
-  ComposerSubmitDom,
-  ComposerSubmitState,
-} from "./composer-submit-controller.js";
+import type { ComposerDraft, ComposerDrafts, ComposerScope } from "./composer-drafts.js";
+import type { ComposerDraftInput, ComposerDraftView, ComposerInputSurface } from "./composer-draft-view.js";
 
-export interface ComposerWorkspaceDom extends ComposerSubmitDom {
+export interface ComposerWorkspaceDom {
+  composerInput: ComposerDraftInput;
   composerForm: HTMLElement;
   runtimeSetupGuide?: HTMLElement;
-  [name: string]: unknown;
-}
-
-export type HomeComposerState = ComposerAttachmentsState &
-  ComposerSubmitState & {
-    environmentId: string;
-    text: string;
-  };
-
-export interface HomeComposerDraft {
-  sessionId: string;
-  environmentId: string;
-  text: string;
-  attachments: ComposerAttachment[];
 }
 
 export interface ComposerWorkspaceController<T extends ComposerWorkspaceDom = ComposerWorkspaceDom> {
-  chatDom: Omit<T, "composerInput"> & ComposerSubmitDom;
-  homeDom: Omit<T, "composerInput"> & ComposerSubmitDom;
-  homeState: HomeComposerState;
+  drafts: ComposerDrafts;
+  chatDraft(): ComposerDraft;
+  homeDraft(): ComposerDraft;
+  chatView: ComposerDraftView;
+  homeView: ComposerDraftView;
+  chatDom: Omit<T, "composerInput"> & { composerInput: ComposerInputSurface };
+  homeDom: Omit<T, "composerInput"> & { composerInput: ComposerInputSurface };
   setWorkspace(workspace: string): void;
   isHome(): boolean;
   isChatVisible(): boolean;
   composerSessionId(): string;
   ensureHomeSession(): string;
-  resetHomeDraft(): void;
-  takeHomeDraft(text: string): HomeComposerDraft;
-  restoreHomeDraft(draft: HomeComposerDraft): void;
+  finishHomeActivation(scope: ComposerScope): void;
   syncChatDraft(): void;
 }
 
-export declare function createComposerWorkspaceController<T extends ComposerWorkspaceDom>(
-  options: {
-    state: Pick<ComposerSubmitState, "currentSessionId">;
-    dom: T;
-    homeComposerHost: HTMLElement;
-    homeSetupHost?: HTMLElement;
-    selectedEnvironmentId(): string;
-    createSessionId?(): string;
-    onSessionCreated?(sessionId: string): void;
-  },
-): ComposerWorkspaceController<T>;
+export declare function createComposerWorkspaceController<T extends ComposerWorkspaceDom>(options: {
+  state: { currentSessionId: string };
+  dom: T;
+  homeComposerHost: HTMLElement;
+  homeSetupHost?: HTMLElement;
+  selectedEnvironmentId(): string;
+  createSessionId?(): string;
+  onSessionCreated?(sessionId: string): void;
+  drafts?: ComposerDrafts;
+}): ComposerWorkspaceController<T>;

package/dist/src/web-ui/app/controllers/composer-workspace-controller.js

@@ -1,181 +1,65 @@
 import { createWebSessionId } from "../lib/text-format.js";
+import { createComposerDrafts } from "./composer-drafts.js";
+import { createComposerDraftView } from "./composer-draft-view.js";
 
+/** Places the shared Home/Chat controls and selects a draft; it owns no payload. */
 export function createComposerWorkspaceController({
-  state,
-  dom,
-  homeComposerHost,
-  homeSetupHost,
-  selectedEnvironmentId,
-  createSessionId = createWebSessionId,
-  onSessionCreated = () => {},
+  state, dom, homeComposerHost, homeSetupHost, selectedEnvironmentId,
+  createSessionId = createWebSessionId, onSessionCreated = () => {},
+  drafts = createComposerDrafts(),
 }) {
-  const surfaces = [{
-    element: dom.composerForm,
-    homeHost: homeComposerHost,
-    chatHost: dom.composerForm.parentElement,
-    nextSibling: dom.composerForm.nextSibling,
-  }];
-  if (homeSetupHost && dom.runtimeSetupGuide) {
-    surfaces.push({
-      element: dom.runtimeSetupGuide,
-      homeHost: homeSetupHost,
-      chatHost: dom.runtimeSetupGuide.parentElement,
-      nextSibling: dom.runtimeSetupGuide.nextSibling,
-    });
-  }
-  const chatDrafts = new Map();
-  const homeState = {
-    currentSessionId: "",
-    activeRequestId: "",
-    pendingAttachments: [],
-    pendingAttachmentUploadCounts: new Map(),
-    composerAttachmentGeneration: 0,
-    composerSending: false,
-    environmentId: selectedEnvironmentId(),
-    text: "",
-  };
+  const surfaces = [{ element: dom.composerForm, homeHost: homeComposerHost,
+    chatHost: dom.composerForm.parentElement, nextSibling: dom.composerForm.nextSibling }];
+  if (homeSetupHost && dom.runtimeSetupGuide) surfaces.push({
+    element: dom.runtimeSetupGuide, homeHost: homeSetupHost,
+    chatHost: dom.runtimeSetupGuide.parentElement, nextSibling: dom.runtimeSetupGuide.nextSibling,
+  });
+  const homeSessions = new Map();
   let workspace = "chat";
-  let displayedSource = "chat";
-  let displayedChatKey = currentChatKey();
-
-  function currentChatKey() {
-    return JSON.stringify([selectedEnvironmentId(), state.currentSessionId]);
-  }
-
-  function saveDisplayedText() {
-    if (displayedSource === "home") {
-      homeState.text = dom.composerInput.value;
-      return;
-    }
-    chatDrafts.set(displayedChatKey, dom.composerInput.value);
-  }
-
-  function isHome() {
-    return workspace === "home";
-  }
-
-  function isChatVisible() {
-    return workspace === "chat";
-  }
-
-  function isCurrentChatInputDisplayed() {
-    if (displayedSource !== "chat") return false;
-    return displayedChatKey === currentChatKey();
-  }
-
-  function createInputSurface(source) {
-    const parkedStyle = { height: "" };
-    const isDisplayed = () =>
-      source === "home"
-        ? displayedSource === "home"
-        : isCurrentChatInputDisplayed();
-    const isVisible = () => source === "home" ? isHome() : isChatVisible();
-    return {
-      get value() {
-        if (isDisplayed()) return dom.composerInput.value;
-        if (source === "home") return homeState.text;
-        return chatDrafts.get(currentChatKey()) || "";
-      },
-      set value(value) {
-        if (source === "home") homeState.text = value;
-        else chatDrafts.set(currentChatKey(), value);
-        if (isDisplayed()) dom.composerInput.value = value;
-      },
-      get style() {
-        return isDisplayed() ? dom.composerInput.style : parkedStyle;
-      },
-      get scrollHeight() {
-        return isDisplayed() ? dom.composerInput.scrollHeight : 0;
-      },
-      focus() {
-        if (!isVisible()) return;
-        if (isDisplayed()) dom.composerInput.focus();
-      },
-    };
-  }
 
   function ensureHomeSession() {
-    if (homeState.currentSessionId) return homeState.currentSessionId;
-    homeState.currentSessionId = createSessionId();
-    onSessionCreated(homeState.currentSessionId);
-    return homeState.currentSessionId;
+    const environment = selectedEnvironmentId();
+    if (homeSessions.has(environment)) return homeSessions.get(environment);
+    const session = createSessionId();
+    homeSessions.set(environment, session);
+    onSessionCreated(session);
+    return session;
   }
-
-  function moveWorkspaceSurface(surface) {
-    if (isHome()) {
-      surface.homeHost.appendChild(surface.element);
-      return;
-    }
-    const nextSibling = surface.nextSibling?.parentElement === surface.chatHost
-      ? surface.nextSibling
-      : null;
-    surface.chatHost.insertBefore(surface.element, nextSibling);
+  const chatDraft = () => drafts.open({ environmentId: selectedEnvironmentId(), sessionId: state.currentSessionId });
+  const homeDraft = () => drafts.open({ environmentId: selectedEnvironmentId(), sessionId: ensureHomeSession() });
+  const isHome = () => workspace === "home";
+  const isChatVisible = () => workspace === "chat";
+  const chatView = createComposerDraftView({ input: dom.composerInput, getDraft: chatDraft, isVisible: isChatVisible });
+  const homeView = createComposerDraftView({ input: dom.composerInput, getDraft: homeDraft, isVisible: isHome });
+
+  function moveSurface(surface) {
+    if (isHome()) { surface.homeHost.appendChild(surface.element); return; }
+    const sibling = surface.nextSibling?.parentElement === surface.chatHost ? surface.nextSibling : null;
+    surface.chatHost.insertBefore(surface.element, sibling);
   }
-
-  function setWorkspace(nextWorkspace) {
-    saveDisplayedText();
-    workspace = nextWorkspace;
-    displayedSource = isHome() ? "home" : "chat";
-    displayedChatKey = currentChatKey();
-    dom.composerInput.value = isHome()
-      ? homeState.text
-      : chatDrafts.get(displayedChatKey) || "";
-    if (isHome()) ensureHomeSession();
-    for (const surface of surfaces) moveWorkspaceSurface(surface);
+  function setWorkspace(next) {
+    if (isHome()) homeView.detach();
+    else chatView.detach();
+    workspace = next;
+    if (isHome()) homeView.display();
+    else chatView.display();
+    for (const surface of surfaces) moveSurface(surface);
   }
-
   function syncChatDraft() {
-    if (displayedSource !== "chat") return;
-    if (isCurrentChatInputDisplayed()) return;
-    setWorkspace(workspace);
-  }
-
-  function resetHomeDraft() {
-    homeState.currentSessionId = "";
-    homeState.composerSending = false;
-    homeState.pendingAttachments = [];
-    homeState.composerAttachmentGeneration += 1;
-    homeState.pendingAttachmentUploadCounts.clear();
-    homeState.environmentId = selectedEnvironmentId();
-    homeState.text = "";
-    if (displayedSource === "home") dom.composerInput.value = "";
-  }
-
-  function takeHomeDraft(text) {
-    const draft = {
-      sessionId: ensureHomeSession(),
-      environmentId: homeState.environmentId,
-      text,
-      attachments: [...homeState.pendingAttachments],
-    };
-    resetHomeDraft();
-    return draft;
-  }
-
-  function restoreHomeDraft(draft) {
-    homeState.currentSessionId = draft.sessionId;
-    homeState.environmentId = draft.environmentId;
-    homeState.pendingAttachments = draft.attachments;
-    homeState.text = draft.text;
-    if (displayedSource === "home") dom.composerInput.value = draft.text;
-  }
-
-  function composerSessionId() {
-    return isHome() ? ensureHomeSession() : state.currentSessionId;
+    if (isHome()) { homeView.display(); return; }
+    chatView.display();
   }
+  drafts.subscribe((draft) => { chatView.refresh(draft); homeView.refresh(draft); });
+  chatView.display();
 
   return {
-    chatDom: { ...dom, composerInput: createInputSurface("chat") },
-    homeDom: { ...dom, composerInput: createInputSurface("home") },
-    homeState,
-    setWorkspace,
-    isHome,
-    isChatVisible,
-    composerSessionId,
-    ensureHomeSession,
-    resetHomeDraft,
-    takeHomeDraft,
-    restoreHomeDraft,
-    syncChatDraft,
+    drafts, chatDraft, homeDraft, chatView, homeView,
+    chatDom: { ...dom, composerInput: chatView.surface },
+    homeDom: { ...dom, composerInput: homeView.surface },
+    isHome, isChatVisible, setWorkspace, syncChatDraft, ensureHomeSession,
+    composerSessionId: () => isHome() ? ensureHomeSession() : state.currentSessionId,
+    finishHomeActivation(scope) {
+      if (homeSessions.get(scope.environmentId) === scope.sessionId) homeSessions.delete(scope.environmentId);
+    },
   };
 }