@abot-ai/runtime 1.7.0 → 1.8.1

package/dist/src/web-ui/app/controllers/composer-draft-view.js

@@ -0,0 +1,48 @@
+/** Binds a textarea to one draft handle; changing the view never disposes a draft. */
+export function createComposerDraftView({ input, getDraft, isVisible = () => true }) {
+  let displayed = null;
+  const parkedStyle = { height: "" };
+
+  function saveDisplayed() {
+    if (displayed) displayed.text = input.value;
+  }
+
+  function display() {
+    const next = getDraft();
+    if (next !== displayed) {
+      saveDisplayed();
+      displayed = next;
+      input.value = next.text;
+    }
+    return next;
+  }
+
+  function current() {
+    const draft = getDraft();
+    if (displayed === draft) draft.text = input.value;
+    return draft;
+  }
+
+  const surface = {
+    get value() { return current().text; },
+    set value(value) {
+      const draft = getDraft();
+      draft.text = value;
+      if (displayed === draft) input.value = draft.text;
+    },
+    get style() { return isVisible() ? input.style : parkedStyle; },
+    get scrollHeight() { return isVisible() ? input.scrollHeight : 0; },
+    focus() { if (isVisible()) input.focus(); },
+  };
+
+  input.addEventListener?.("input", saveDisplayed);
+
+  return {
+    surface, current, display, saveDisplayed,
+    refresh(draft) {
+      if (displayed !== draft) return;
+      input.value = draft.text;
+    },
+    detach() { saveDisplayed(); displayed = null; },
+  };
+}

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

@@ -0,0 +1,55 @@
+import type {
+  ReleasedSessionComposerQueueItem,
+  SessionComposerAttachmentRef,
+  SessionComposerQueueScope,
+} from "../lib/session-composer-queue.js";
+
+export type ComposerScope = Readonly<SessionComposerQueueScope>;
+export type ComposerAttachment = SessionComposerAttachmentRef & {
+  id?: string;
+  kind?: string;
+  name?: string;
+  mimeType?: string;
+  sessionId?: string;
+  storageRef?: string;
+  environment?: string;
+};
+
+export interface ComposerDraftSnapshot {
+  readonly scope: ComposerScope;
+  readonly text: string;
+  readonly attachments: readonly ComposerAttachment[];
+  readonly release: ReleasedSessionComposerQueueItem | null;
+}
+
+/** Mutable editing handle owned by the window-lifetime draft registry. */
+export interface ComposerDraft {
+  readonly scope: ComposerScope;
+  text: string;
+  attachments: ComposerAttachment[];
+  readonly revision: number;
+  readonly generation: number;
+  readonly release: ReleasedSessionComposerQueueItem | null;
+  readonly uploading: number;
+  isEmpty(): boolean;
+  setRelease(release: ReleasedSessionComposerQueueItem | null): void;
+  startUpload(): number;
+  finishUpload(generation: number): void;
+  acceptUpload(generation: number, attachment: ComposerAttachment): boolean;
+  snapshot(): ComposerDraftSnapshot;
+  take(): ComposerDraftSnapshot;
+  restore(snapshot: ComposerDraftSnapshot): void;
+  clearAttachments(): ComposerAttachment[];
+  contains(attachment: ComposerAttachment): boolean;
+}
+
+export interface ComposerDrafts {
+  clearAttachments(scope: ComposerScope): ComposerAttachment[];
+  open(scope: ComposerScope): ComposerDraft;
+  restore(snapshot: ComposerDraftSnapshot): void;
+  assignSession(draft: ComposerDraft, sessionId: string): ComposerDraft;
+  contains(attachment: ComposerAttachment): boolean;
+  subscribe(listener: (draft: ComposerDraft) => void): () => boolean;
+}
+
+export declare function createComposerDrafts(): ComposerDrafts;

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

@@ -0,0 +1,120 @@
+function scopeKey(scope) {
+  return JSON.stringify([scope.environmentId, scope.sessionId]);
+}
+
+function attachmentKey(attachment) {
+  return JSON.stringify([attachment.environment, attachment.sessionId, attachment.storageRef, attachment.id]);
+}
+
+function combineAttachments(previous, current) {
+  const files = new Map();
+  for (const file of [...previous, ...current]) files.set(attachmentKey(file), file);
+  return [...files.values()];
+}
+
+/** Window-lifetime drafts. DOM, navigation and requests borrow handles, not copies. */
+export function createComposerDrafts() {
+  const records = new Map();
+  const listeners = new Set();
+
+  function notify(draft) {
+    for (const listener of listeners) listener(draft);
+  }
+
+  function open(scope) {
+    const key = scopeKey(scope);
+    const existing = records.get(key);
+    if (existing) return existing;
+    const identity = Object.freeze({ ...scope });
+    let text = "";
+    let files = [];
+    let revision = 0;
+    let generation = 0;
+    let queueRelease = null;
+    const uploads = new Map();
+    const changed = () => { revision += 1; notify(draft); };
+    const draft = {
+      scope: identity,
+      get text() { return text; },
+      set text(value) {
+        const next = String(value);
+        if (text === next) return;
+        text = next; changed();
+      },
+      get attachments() { return [...files]; },
+      set attachments(value) { files = [...value]; changed(); },
+      get revision() { return revision; },
+      get generation() { return generation; },
+      get release() { return queueRelease; },
+      get uploading() { return uploads.get(generation) || 0; },
+      isEmpty() { return !text && files.length === 0 && !queueRelease; },
+      setRelease(release) { queueRelease = release; changed(); },
+      startUpload() {
+        const captured = generation;
+        uploads.set(captured, (uploads.get(captured) || 0) + 1);
+        notify(draft);
+        return captured;
+      },
+      finishUpload(captured) {
+        const count = (uploads.get(captured) || 0) - 1;
+        if (count <= 0) uploads.delete(captured);
+        else uploads.set(captured, count);
+        notify(draft);
+      },
+      acceptUpload(captured, attachment) {
+        if (captured !== generation) return false;
+        files = combineAttachments(files, [attachment]);
+        changed();
+        return true;
+      },
+      snapshot() {
+        return Object.freeze({ scope: identity, text, attachments: Object.freeze([...files]), release: queueRelease });
+      },
+      take() {
+        const captured = draft.snapshot();
+        text = "";
+        files = [];
+        queueRelease = null;
+        generation += 1;
+        changed();
+        return captured;
+      },
+      restore(captured) {
+        if (scopeKey(captured.scope) !== key) throw new Error("Cannot restore a draft into a different conversation.");
+        if (captured.release && queueRelease && captured.release.releaseToken !== queueRelease.releaseToken)
+          throw new Error("Another queued message already owns this draft.");
+        text = text ? `${captured.text}\n${text}` : captured.text;
+        files = combineAttachments(captured.attachments, files);
+        queueRelease = captured.release ?? queueRelease;
+        changed();
+      },
+      clearAttachments() {
+        const removed = files;
+        files = [];
+        generation += 1;
+        changed();
+        return removed;
+      },
+      contains(attachment) { return files.some((file) => attachmentKey(file) === attachmentKey(attachment)); },
+    };
+    records.set(key, draft);
+    return draft;
+  }
+
+  return {
+    open,
+    restore: (captured) => open(captured.scope).restore(captured),
+    clearAttachments: (scope) => records.get(scopeKey(scope))?.clearAttachments() ?? [],
+    assignSession(draft, sessionId) {
+      if (draft.scope.sessionId) return draft;
+      if (draft.uploading) throw new Error("Cannot assign a conversation while a file is uploading.");
+      const target = open({ ...draft.scope, sessionId });
+      const captured = draft.take();
+      target.restore({ ...captured, scope: target.scope });
+      records.delete(scopeKey(draft.scope));
+      return target;
+    },
+    contains: (attachment) => [...records.values()].some((draft) => draft.contains(attachment)),
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+  };
+}

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

@@ -0,0 +1,65 @@
+import type { SessionComposerQueue, RemoteSessionComposerQueue } from "../lib/session-composer-queue.js";
+import type { ComposerAttachmentsClient, ComposerAttachmentsController, ComposerAttachmentsDom, ComposerAttachmentsShell } from "./composer-attachments-controller.js";
+import type { ChatRequestController, ComposerChatClient, ComposerChatSession } from "./chat-request-controller.js";
+import type { ComposerDraft, ComposerDraftSnapshot, ComposerDrafts, ComposerScope } from "./composer-drafts.js";
+import type { ComposerQueueController } from "./composer-queue-controller.js";
+import type { ComposerSubmissionLifecycle, ComposerSubmissionSettings } from "./composer-submission-lifecycle.js";
+import type { createRealtimeEventController } from "./realtime-event-controller.js";
+import type { ComposerSubmissionBlock, ComposerSubmitActions, ComposerSubmitController, ComposerSubmitDom, ComposerSubmitState } from "./composer-submit-controller.js";
+
+export interface ComposerSurfaceDom extends ComposerSubmitDom, ComposerAttachmentsDom {
+  composerForm?: HTMLElement;
+}
+export interface ComposerSurfaceOptions {
+  surfaceDom: ComposerSurfaceDom;
+  currentDraft(): ComposerDraft;
+  ensureDraftSession(): string;
+  visible(): boolean;
+  supportsImages(): boolean;
+  available?(): boolean;
+  prepareSend?(payload: ComposerDraftSnapshot): boolean | void | Promise<boolean | void>;
+  allowsActiveRequest?: boolean;
+}
+export interface ComposerSurface {
+  attachments: ComposerAttachmentsController;
+  submit: ComposerSubmitController;
+  render(): void;
+  displays(scope: ComposerScope): boolean;
+}
+export interface ComposerFeatureOptions {
+  state: ComposerSubmitState;
+  dom: ComposerSurfaceDom;
+  shell: ComposerAttachmentsShell;
+  client: ComposerChatClient & ComposerAttachmentsClient;
+  sessionQueue: SessionComposerQueue | RemoteSessionComposerQueue;
+  conversationSession: ComposerChatSession;
+  conversationView: { reset(): void };
+  getEnvironmentId(): string;
+  getDraft(): ComposerDraft;
+  ensureSession(): string;
+  getSettings(): ComposerSubmissionSettings;
+  steer(text: string, options: { scope: ComposerScope & { requestId: string }; pendingAttachmentCount: number }): Promise<void>;
+  composerActions: ComposerSubmitActions;
+  selectedModelSupportsImageInput(): boolean;
+  isComposerAvailable?(): boolean;
+  getSubmissionBlock?(): ComposerSubmissionBlock | null;
+  onSubmissionBlocked?(block: ComposerSubmissionBlock): void;
+  isVisible?(): boolean;
+  renderSessions(): void;
+  renderMessages(): void;
+  applyConversationChrome(): void;
+  setMessageStatus(message: string, busy?: boolean): void;
+  recordControlEvent: ReturnType<typeof createRealtimeEventController>["recordControlEvent"];
+  drafts?: ComposerDrafts;
+  onChange?(): void;
+  confirmReview?(message: string): boolean;
+}
+export interface ComposerFeature extends ComposerSurface {
+  queue: ComposerQueueController;
+  requests: ChatRequestController;
+  drafts: ComposerDrafts;
+  lifecycle: ComposerSubmissionLifecycle;
+  createSurface(options: ComposerSurfaceOptions): ComposerSurface;
+  changed(): void;
+}
+export declare function createComposerFeature(options: ComposerFeatureOptions): ComposerFeature;

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

@@ -0,0 +1,124 @@
+import { createComposerDrafts } from "./composer-drafts.js";
+import { createComposerSubmissionLifecycle, ComposerSubmissionRefused } from "./composer-submission-lifecycle.js";
+import { createComposerAttachmentsController } from "./composer-attachments-controller.js";
+import { createComposerQueueController } from "./composer-queue-controller.js";
+import { createComposerSubmitController } from "./composer-submit-controller.js";
+import { createChatRequestController } from "./chat-request-controller.js";
+import { createComposerSubmissionNotice } from "../components/composer-submission-notice.js";
+
+/** Production composition reused by Chat/Home and the SPARK popup, and integration tests. */
+export function createComposerFeature({
+  state, dom, shell, client, sessionQueue, conversationSession, conversationView,
+  getEnvironmentId, getDraft, ensureSession, getSettings, steer,
+  composerActions, selectedModelSupportsImageInput, isComposerAvailable,
+  getSubmissionBlock, onSubmissionBlocked, isVisible = () => true,
+  renderSessions, renderMessages, applyConversationChrome, setMessageStatus, recordControlEvent,
+  drafts = createComposerDrafts(), onChange = () => {},
+  confirmReview = (message) => globalThis.confirm?.(message) === true,
+}) {
+  const surfaces = [];
+  let queue;
+  const isCurrentScope = (scope) => getEnvironmentId() === scope.environmentId && state.currentSessionId === scope.sessionId;
+  function reportStatus(scope, message, tone) {
+    const hasVisibleDraft = surfaces.some((surface) => surface.displays(scope));
+    if (!isCurrentScope(scope) && !hasVisibleDraft) return;
+    setMessageStatus(message);
+    recordControlEvent({ type: "control", name: "Composer message paused", tone, summary: message });
+  }
+  const reportFailure = (scope, message) => reportStatus(scope, message, "failed");
+  const reportRecovery = (scope, message) => reportStatus(scope, message, "neutral");
+  function changed() {
+    for (const surface of surfaces) surface.render();
+    onChange();
+  }
+  const lifecycle = createComposerSubmissionLifecycle({ drafts, onChange: changed });
+  Object.defineProperty(state, "composerSending", { configurable: true, get: () => lifecycle.hasPendingScope(getDraft().scope) });
+  Object.defineProperty(state, "pendingAttachments", { configurable: true, get: () => getDraft().attachments });
+  const requests = createChatRequestController({ client, conversationView, conversationSession,
+    isCurrentComposerScope: isCurrentScope, applyConversationChrome, renderSessions });
+  queue = createComposerQueueController({ queue: sessionQueue, drafts, lifecycle, getDraft, requests, getSettings,
+    isCurrentScope, reportFailure, reportRecovery, onChange: changed, confirmTakeover: confirmReview });
+
+  function createSurface({ surfaceDom, currentDraft, ensureDraftSession, visible, supportsImages,
+    available = isComposerAvailable, prepareSend = () => true, allowsActiveRequest = true }) {
+    const attachments = createComposerAttachmentsController({
+      getDraft: currentDraft, dom: surfaceDom, shell, client, selectedEnvironmentId: getEnvironmentId,
+      selectedModelSupportsImageInput: supportsImages, ensureSession: ensureBoundSession,
+      isComposerAvailable: available, isComposerVisible: visible,
+      onSendStateChange: () => submit.updateSendState(), onControlEvent: recordControlEvent,
+      canDeleteAttachment: (file) => !drafts.contains(file) && !lifecycle.ownsAttachment(file) && !queue.ownsAttachment(file),
+    });
+    const notice = createComposerSubmissionNotice({ form: surfaceDom.composerForm, review: async (attempt) => {
+      if (!confirmReview("Check the conversation first: this message may already have been sent. Restore it for manual review? Sending it again may repeat its actions.")) return;
+      try { await lifecycle.restoreForManualReview(attempt.id, queue.authorizeReview); }
+      catch (error) { reportFailure(attempt.payload.scope, error.message); }
+    }, recover: async (scope) => {
+      try { await queue.recoverForManualSend(scope); }
+      catch (error) { reportFailure(scope, error.message); }
+      changed();
+    } });
+    function render() {
+      if (!visible()) { notice.render([]); return; }
+      attachments.render();
+      submit.updateSendState();
+      const draft = currentDraft();
+      const recovery = queue.hasManualRecovery(draft.scope)
+        ? { scope: draft.scope, draftEmpty: draft.isEmpty() } : null;
+      notice.render(lifecycle.paused(draft.scope), recovery);
+    }
+    function ensureBoundSession() {
+      const draft = currentDraft();
+      const sessionId = ensureDraftSession();
+      drafts.assignSession(draft, sessionId);
+      return sessionId;
+    }
+    function send(action) {
+      let draft = currentDraft();
+      draft.text = surfaceDom.composerInput.value.trim();
+      const settings = getSettings();
+      if (!draft.scope.sessionId) { ensureBoundSession(); draft = currentDraft(); }
+      const activeRequestId = allowsActiveRequest ? state.activeRequestId : "";
+      return lifecycle.submit({ draft, action, settings,
+        prepare: async (attempt) => {
+          if (attempt.payload.release && activeRequestId)
+            throw new ComposerSubmissionRefused("Wait for the active request to finish before sending this recovered message.");
+          if (attempt.payload.release && action !== "send")
+            throw new ComposerSubmissionRefused("A recovered queued message must be sent directly after review.");
+          if (action !== "send") return;
+          if (await prepareSend(attempt.payload) === false)
+            throw new ComposerSubmissionRefused("Conversation navigation was cancelled. Your draft was kept.");
+          await queue.prepareManualSend(attempt);
+          requests.prepareView(attempt);
+        },
+        execute: (attempt) => {
+          if (action === "send_next") return queue.enqueue(attempt, activeRequestId);
+          if (action === "steer") return steer(attempt.payload.text, { scope: { ...attempt.payload.scope, requestId: activeRequestId }, pendingAttachmentCount: attempt.payload.attachments.length });
+          return queue.send(attempt);
+        },
+        prepareRestore: queue.prepareRestore,
+        accepted: async (attempt, result) => {
+          if (action === "send") await queue.bindAccepted(attempt, result);
+        },
+      }).then((result) => {
+        if (result.status === "refused") reportFailure(result.attempt.payload.scope, result.error.message);
+        if (result.status === "uncertain") reportFailure(result.attempt.payload.scope, "The message could not be confirmed. It is paused for manual review.");
+        return result;
+      });
+    }
+    const submit = createComposerSubmitController({ state, dom: surfaceDom, composerActions,
+      getDraft: currentDraft, attachments, queue, lifecycle, submit: send,
+      stopRequest: requests.stopRequest, selectedEnvironmentId: getEnvironmentId, setMessageStatus,
+      getSubmissionBlock, onSubmissionBlocked, isComposerVisible: visible, allowsActiveRequest });
+    const surface = { attachments, submit, render, displays: (scope) => {
+      if (!visible()) return false;
+      const current = currentDraft().scope;
+      return current.environmentId === scope.environmentId && current.sessionId === scope.sessionId;
+    } };
+    surfaces.push(surface);
+    return surface;
+  }
+  const chat = createSurface({ surfaceDom: dom, currentDraft: getDraft, ensureDraftSession: ensureSession,
+    visible: isVisible, supportsImages: selectedModelSupportsImageInput });
+  drafts.subscribe(changed);
+  return { ...chat, queue, requests, drafts, lifecycle, createSurface, changed };
+}

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

@@ -1,110 +1,49 @@
-import type {
-  SessionComposerAttachmentRef,
-  SessionComposerModelPreference,
-  SessionComposerQueue,
-} from "../lib/session-composer-queue.js";
+import type { RemoteSessionComposerQueue, SessionComposerQueue, SessionComposerQueueItem } from "../lib/session-composer-queue.js";
+import type { ComposerAttachment, ComposerDraft, ComposerDraftSnapshot, ComposerDrafts, ComposerScope } from "./composer-drafts.js";
+import type { ChatRequestController, ComposerChatAttempt } from "./chat-request-controller.js";
+import type { ComposerReviewAuthorization, ComposerSubmissionAttempt, ComposerSubmissionLifecycle, ComposerSubmissionSettings } from "./composer-submission-lifecycle.js";
 
-export type ComposerScope = Readonly<{
-  environmentId: string;
-  sessionId: string;
-}>;
-
-export type ComposerQueueDrainScope = ComposerScope &
-  Readonly<{ terminalRequestId: string; cancelled?: boolean }>;
-
-export interface ComposerQueueRecovery {
-  scope: ComposerScope;
-  releaseToken: string;
-}
-
-export interface ComposerQueueMessage {
-  id?: string;
-  role?: string;
-  text?: string;
-  createdAt?: unknown;
-  requestId?: string;
-  streaming?: boolean;
-}
-
-export interface ComposerQueueState {
-  activeRequestId: string;
-  agentMode: string;
-  currentSessionId: string;
-  pendingAttachments: SessionComposerAttachmentRef[];
-  composerQueueDrainingScopes: Set<string>;
-  composerQueueRecoveredReleaseTokens: Set<string>;
-  activeComposerQueueRecovery: ComposerQueueRecovery | null;
-  messages: ComposerQueueMessage[];
-}
-
-export interface ComposerQueueDom {
-  composerInput: {
-    value: string;
-  };
-}
-
-export interface ComposerQueueAttachments {
-  clear(options?: { cleanup?: boolean }): void;
-  invalidateCompletions(): void;
-  render(): void;
-}
-
-export interface ComposerQueuePostChatRequest {
-  text: string;
-  attachments: SessionComposerAttachmentRef[];
-  environmentId: string;
-  sessionId: string;
-  agentMode: string;
-  toolPermissionMode: string;
-  modelPreference: SessionComposerModelPreference | null;
-}
-
-export interface ComposerQueueControlEvent {
-  type: "control";
-  name: string;
-  tone: "failed" | "neutral";
-  summary: string;
+export type { ComposerScope } from "./composer-drafts.js";
+export type ComposerQueueDrainScope = ComposerScope & Readonly<{ terminalRequestId: string; cancelled?: boolean }>;
+export interface ComposerNavigationCommit {
+  (): void;
+  canCommit?(): boolean;
 }
+export type ComposerNavigationPreparation = false | ComposerNavigationCommit;
 
 export interface ComposerQueueControllerOptions {
-  state: ComposerQueueState;
-  dom: ComposerQueueDom;
-  queue: SessionComposerQueue;
-  selectedEnvironmentId: () => string;
-  getToolPermissionMode: () => string;
-  getModelPreference: () => SessionComposerModelPreference | null;
-  rememberModelSelection: () => void;
-  attachments: ComposerQueueAttachments;
-  updateSendState: () => void;
-  postChatMessage: (request: ComposerQueuePostChatRequest) => Promise<string>;
-  appendLocalUserMessage: (message: {
-    text: string;
-    attachments: SessionComposerAttachmentRef[];
-    requestId: string;
-  }) => void;
-  activateRequestForScope: (scope: ComposerScope, requestId: string) => void;
-  renderMessages: () => void;
-  setMessageStatus: (message: string, busy?: boolean) => void;
-  recordControlEvent: (event: ComposerQueueControlEvent) => void;
-  resizeComposer: () => void;
+  queue: SessionComposerQueue | RemoteSessionComposerQueue;
+  drafts: ComposerDrafts;
+  lifecycle: ComposerSubmissionLifecycle;
+  getDraft(): ComposerDraft;
+  requests: Pick<ChatRequestController, "send" | "prepareView" | "activate">;
+  getSettings(): ComposerSubmissionSettings;
+  isCurrentScope(scope: ComposerScope): boolean;
+  reportFailure(scope: ComposerScope, summary: string): void;
+  reportRecovery?(scope: ComposerScope, summary: string): void;
+  onChange?(): void;
+  confirmTakeover?(message: string): boolean;
 }
 
 export interface ComposerQueueController {
-  clearRecovery(scope: ComposerScope): void;
   currentScope(): ComposerScope;
   drain(scope: ComposerQueueDrainScope): Promise<void>;
-  enqueue(text: string): Promise<void>;
+  enqueue(attempt: ComposerChatAttempt, waitForRequestId: string): Promise<SessionComposerQueueItem>;
   isCurrentDraining(): boolean;
   isCurrentScope(scope: ComposerScope): boolean;
-  prepareRecoveryForNavigation(): false | (() => void);
+  prepareManualSend(attempt: ComposerChatAttempt): Promise<void>;
+  send(attempt: ComposerChatAttempt): Promise<string>;
+  bindAccepted(attempt: ComposerSubmissionAttempt, requestId: string): Promise<void>;
+  prepareRestore(attempt: ComposerSubmissionAttempt): Promise<ComposerDraftSnapshot>;
+  prepareRecoveryForNavigation(): ComposerNavigationCommit | Promise<ComposerNavigationPreparation>;
+  suspendRecoveryForNavigation(canNavigate?: () => boolean): boolean | Promise<boolean>;
   queuedCount(): number;
-  recoverForManualSend(scope: ComposerScope): boolean;
+  recoverForManualSend(scope: ComposerScope): Promise<boolean>;
+  hasManualRecovery(scope: ComposerScope): boolean;
   reportFailure(scope: ComposerScope, summary: string): void;
-  restoreText(text: string, scope: ComposerScope): void;
   scopeKey(scope: ComposerScope): string;
-  suspendRecoveryForNavigation(): boolean;
+  authorizeReview(attempt: ComposerSubmissionAttempt): Promise<ComposerReviewAuthorization>;
+  ownsAttachment(attachment: ComposerAttachment): boolean;
 }
 
-export declare function createComposerQueueController(
-  options: ComposerQueueControllerOptions,
-): ComposerQueueController;
+export declare function createComposerQueueController(options: ComposerQueueControllerOptions): ComposerQueueController;