@get-bb/plugin-sdk 0.5.30 → 0.6.5

package/dist/testing/app.js

@@ -16,6 +16,522 @@ function isComposerDraftEmpty(text, attachmentCount) {
   return text.trim().length === 0 && attachmentCount === 0;
 }
 
+// src/internal/composer-draft-transforms.ts
+function removeComposerMentions(draft, matches) {
+  const removed = draft.mentions.filter(matches).sort((a, b) => a.from - b.from);
+  if (removed.length === 0) return draft;
+  let text = "";
+  let cursor = 0;
+  for (const mention of removed) {
+    text += draft.text.slice(cursor, mention.from);
+    cursor = mention.to;
+  }
+  const removedSet = new Set(removed);
+  const mentions = draft.mentions.filter((mention) => !removedSet.has(mention)).map((mention) => {
+    const offset = removed.reduce(
+      (sum, item) => sum + (item.to <= mention.from ? item.to - item.from : 0),
+      0
+    );
+    return offset === 0 ? mention : { ...mention, from: mention.from - offset, to: mention.to - offset };
+  });
+  return { ...draft, text: text + draft.text.slice(cursor), mentions };
+}
+function setComposerText(draft, text) {
+  if (text === draft.text) return draft;
+  return {
+    ...draft,
+    text,
+    mentions: reconcileComposerMentions(draft.text, text, draft.mentions)
+  };
+}
+function reconcileComposerMentions(currentText, nextText, mentions) {
+  if (currentText === nextText) return [...mentions];
+  let unchangedPrefixLength = 0;
+  const maximumPrefixLength = Math.min(currentText.length, nextText.length);
+  while (unchangedPrefixLength < maximumPrefixLength && currentText[unchangedPrefixLength] === nextText[unchangedPrefixLength]) {
+    unchangedPrefixLength += 1;
+  }
+  let unchangedSuffixLength = 0;
+  while (unchangedSuffixLength < currentText.length - unchangedPrefixLength && unchangedSuffixLength < nextText.length - unchangedPrefixLength && currentText[currentText.length - unchangedSuffixLength - 1] === nextText[nextText.length - unchangedSuffixLength - 1]) {
+    unchangedSuffixLength += 1;
+  }
+  const replacedCurrentEnd = currentText.length - unchangedSuffixLength;
+  const replacementDelta = nextText.length - currentText.length;
+  return mentions.flatMap((mention) => {
+    if (mention.to <= unchangedPrefixLength) return [mention];
+    if (mention.from >= replacedCurrentEnd) {
+      return [
+        {
+          ...mention,
+          from: mention.from + replacementDelta,
+          to: mention.to + replacementDelta
+        }
+      ];
+    }
+    return [];
+  });
+}
+
+// src/internal/composer-draft-actions.ts
+import { z } from "zod";
+var range = {
+  from: z.number().int().nonnegative(),
+  to: z.number().int().nonnegative(),
+  label: z.string()
+};
+var mentionSchema = z.discriminatedUnion("kind", [
+  z.object({
+    ...range,
+    kind: z.literal("thread"),
+    threadId: z.string(),
+    projectId: z.string().optional()
+  }),
+  z.object({ ...range, kind: z.literal("project"), projectId: z.string() }),
+  z.object({ ...range, kind: z.literal("section"), sectionId: z.string() }),
+  z.object({
+    ...range,
+    kind: z.literal("path"),
+    path: z.string(),
+    source: z.enum(["workspace", "thread-storage"]),
+    entryKind: z.enum(["file", "directory"])
+  }),
+  z.object({
+    ...range,
+    kind: z.literal("command"),
+    trigger: z.enum(["/", "$"]),
+    name: z.string(),
+    source: z.enum(["skill", "command"]),
+    origin: z.enum(["builtin", "project", "user"]),
+    argumentHint: z.string().nullable()
+  }),
+  z.object({
+    ...range,
+    kind: z.literal("plugin"),
+    pluginId: z.string(),
+    provider: z.string().min(1).refine((value) => !value.includes(":")),
+    id: z.string(),
+    icon: z.string().nullable().optional()
+  })
+]);
+var attachmentsSchema = z.array(
+  z.object({
+    type: z.enum(["localImage", "localFile"]),
+    path: z.string().min(1),
+    name: z.string(),
+    mimeType: z.string().optional(),
+    sizeBytes: z.number().nonnegative()
+  })
+);
+var replacementSchema = z.object({
+  text: z.string(),
+  mentions: z.array(mentionSchema),
+  attachments: attachmentsSchema.optional()
+}).superRefine((draft, context) => {
+  let end = 0;
+  for (const mention of [...draft.mentions].sort((a, b) => a.from - b.from)) {
+    if (mention.from < end || mention.to <= mention.from || mention.to > draft.text.length) {
+      context.addIssue({
+        code: "custom",
+        message: "Mention ranges must be non-overlapping and inside the draft text."
+      });
+    }
+    end = mention.to;
+  }
+});
+function createComposerDraftActions(target) {
+  let cached = null;
+  const snapshotOf = (current) => {
+    const content = current.getDraft();
+    if (cached?.content === content) return cached.snapshot;
+    const snapshot = Object.freeze({
+      text: content.text,
+      mentions: Object.freeze(
+        content.mentions.map((mention) => Object.freeze({ ...mention }))
+      ),
+      attachments: Object.freeze(
+        content.attachments.map(
+          (attachment) => Object.freeze({ ...attachment })
+        )
+      )
+    });
+    cached = { content, snapshot };
+    return snapshot;
+  };
+  const requireAvailable = (current) => {
+    if (!current.isAvailable())
+      throw new Error("This composer is no longer available.");
+  };
+  return {
+    get draft() {
+      return snapshotOf(target());
+    },
+    replace(next) {
+      const current = target();
+      requireAvailable(current);
+      const snapshot = snapshotOf(current);
+      const result = typeof next === "function" ? next(snapshot) : next;
+      requireAvailable(current);
+      if (result === snapshot) return;
+      const parsed = replacementSchema.safeParse(result);
+      if (!parsed.success)
+        throw new Error(
+          "Invalid composer draft: text, mention ranges, or attachments are invalid."
+        );
+      current.setDraft(parsed.data);
+    },
+    focus() {
+      const current = target();
+      requireAvailable(current);
+      current.focus();
+    }
+  };
+}
+
+// src/internal/composer-handle.ts
+var UNAVAILABLE_MESSAGE = "This composer is no longer available.";
+var OFF_SCREEN_MESSAGE = "This composer isn't on screen.";
+var warnedAliases = /* @__PURE__ */ new Set();
+function warnDeprecatedComposerMember(oldName, newName) {
+  if (warnedAliases.has(oldName)) return;
+  warnedAliases.add(oldName);
+  console.warn(
+    `useComposer().${oldName} is deprecated; use useComposer().${newName}.`
+  );
+}
+function appendComposerDraft(current, value, block) {
+  const base = block ? current.text.replace(/\s+$/u, "") : current.text;
+  const separator = block && base.length > 0 ? "\n\n" : "";
+  const offset = base.length + separator.length;
+  return {
+    text: `${base}${separator}${value.text}`,
+    mentions: [
+      ...current.mentions.filter((mention) => mention.to <= base.length),
+      ...value.mentions.map((mention) => ({
+        ...mention,
+        from: mention.from + offset,
+        to: mention.to + offset
+      }))
+    ]
+  };
+}
+function validProviderId(provider) {
+  const trimmed = provider.trim();
+  return trimmed.length === 0 || trimmed.includes(":") ? null : trimmed;
+}
+function insertValue(parts, controller) {
+  const list = Array.isArray(parts) ? parts : [parts];
+  let text = "";
+  const mentions = [];
+  for (const part of list) {
+    if (typeof part === "string") {
+      text += part;
+      continue;
+    }
+    let mention;
+    if ("kind" in part) {
+      mention = part;
+    } else {
+      const provider = validProviderId(part.provider);
+      if (provider === null) {
+        throw new Error(`Invalid mention provider id "${part.provider}".`);
+      }
+      mention = {
+        from: 0,
+        to: 0,
+        label: part.label.trim() || part.id,
+        kind: "plugin",
+        pluginId: controller.pluginId,
+        provider,
+        id: part.id,
+        icon: null
+      };
+    }
+    const serialized = controller.mentionText(mention);
+    mentions.push({
+      ...mention,
+      from: text.length,
+      to: text.length + serialized.length
+    });
+    text += serialized;
+  }
+  return { text, mentions };
+}
+function isDraftEmpty(draft, attachmentCount) {
+  return draft.text.trim().length === 0 && draft.mentions.length === 0 && attachmentCount === 0;
+}
+var legacyDrafts = /* @__PURE__ */ new WeakMap();
+function withLegacyDraftFields(draft, attachmentCount) {
+  const cached = legacyDrafts.get(draft);
+  if (cached) return cached;
+  const snapshot = { ...draft };
+  Object.defineProperties(snapshot, {
+    isEmpty: { value: isDraftEmpty(draft, attachmentCount), enumerable: false },
+    attachmentCount: { value: attachmentCount, enumerable: false }
+  });
+  Object.freeze(snapshot);
+  legacyDrafts.set(draft, snapshot);
+  return snapshot;
+}
+function waitForUploads(target) {
+  return new Promise((resolve) => {
+    if (!target.getEditorState().isAttaching) {
+      resolve();
+      return;
+    }
+    const unsubscribe = target.subscribeEditorState(() => {
+      if (target.getEditorState().isAttaching) return;
+      unsubscribe();
+      resolve();
+    });
+  });
+}
+function createComposerHandleBinding(key, initial) {
+  let controller = initial;
+  const target = () => controller.target;
+  const editorState = () => target().getEditorState();
+  const requireAvailable = () => {
+    if (!target().isAvailable()) throw new Error(UNAVAILABLE_MESSAGE);
+  };
+  const legacyAvailable = (method) => {
+    if (target().isAvailable()) return true;
+    console.warn(
+      `[plugin:${controller.pluginId}] useComposer().${method}: ${UNAVAILABLE_MESSAGE}`
+    );
+    return false;
+  };
+  const replaceText = (nextText) => {
+    const current = target().getDraft();
+    if (nextText === current.text) return;
+    target().setDraft(setComposerText(current, nextText));
+  };
+  const insertMention = (mention) => {
+    warnDeprecatedComposerMember("insertMention", "insert");
+    const provider = validProviderId(mention.provider);
+    if (provider === null) {
+      console.warn(
+        `[plugin:${controller.pluginId}] useComposer().insertMention: invalid provider id "${mention.provider}"`
+      );
+      return;
+    }
+    if (!legacyAvailable("insertMention")) return;
+    const label = mention.label.trim() || mention.id;
+    const current = target().getDraft();
+    const separator = current.text.length === 0 || /\s$/u.test(current.text) ? "" : " ";
+    const from = current.text.length + separator.length;
+    target().setDraft({
+      text: `${current.text}${separator}${label} `,
+      mentions: [
+        ...current.mentions,
+        {
+          from,
+          to: from + label.length,
+          label,
+          kind: "plugin",
+          pluginId: controller.pluginId,
+          provider,
+          id: mention.id,
+          icon: null
+        }
+      ]
+    });
+    target().focus();
+  };
+  const removeMentionFrom = (mention) => {
+    const current = target().getDraft();
+    const next = removeComposerMentions(
+      current,
+      (item) => item.kind === "plugin" && item.pluginId === controller.pluginId && item.provider === mention.provider && item.id === mention.id
+    );
+    if (next !== current) target().setDraft(next);
+  };
+  const removeMention = (mention) => {
+    warnDeprecatedComposerMember("removeMention", "replace");
+    requireAvailable();
+    removeMentionFrom(mention);
+  };
+  const insert = (parts, options = {}) => {
+    requireAvailable();
+    const value = insertValue(parts, controller);
+    const block = options.block === true;
+    if ((options.at ?? "cursor") === "cursor") {
+      if (!target().insertAtCursor(value, block)) {
+        throw new Error(OFF_SCREEN_MESSAGE);
+      }
+      return;
+    }
+    target().setDraft(appendComposerDraft(target().getDraft(), value, block));
+  };
+  const submit = async (options) => {
+    requireAvailable();
+    const hostSubmit = target().submit;
+    if (hostSubmit === void 0) {
+      throw new Error("This composer cannot submit programmatically.");
+    }
+    if (options.sendAt !== void 0 && (!Number.isFinite(options.sendAt) || options.sendAt <= Date.now())) {
+      throw new Error("Pick a time in the future.");
+    }
+    const errorBefore = editorState().attachmentError;
+    await waitForUploads(target());
+    const state = editorState();
+    if (state.attachmentError !== null && state.attachmentError !== errorBefore) {
+      throw new Error(state.attachmentError);
+    }
+    if (state.isSubmittingBlocked) {
+      throw new Error(
+        state.submittingBlockedReason ?? "This composer can't submit right now."
+      );
+    }
+    await hostSubmit(
+      options,
+      options.experimental_data === void 0 ? void 0 : { pluginId: controller.pluginId, data: options.experimental_data }
+    );
+  };
+  const setSelection = async (selection) => {
+    requireAvailable();
+    const hostSetSelection = target().setSelection;
+    if (hostSetSelection === void 0) {
+      throw new Error("This composer has no pickers to set.");
+    }
+    return hostSetSelection(selection);
+  };
+  const submittedListeners = /* @__PURE__ */ new Set();
+  let submittedSubscription = null;
+  const syncSubmittedSubscription = () => {
+    const scope = submittedListeners.size === 0 ? null : JSON.stringify(target().scope);
+    if (submittedSubscription?.scope === scope) return;
+    submittedSubscription?.unsubscribe();
+    submittedSubscription = scope === null ? null : {
+      scope,
+      unsubscribe: controller.onSubmitted(() => {
+        for (const listener of [...submittedListeners]) {
+          try {
+            listener();
+          } catch (error) {
+            console.error("Composer submission listener failed", error);
+          }
+        }
+      })
+    };
+  };
+  const onSubmitted = (listener) => {
+    const entry = () => listener();
+    submittedListeners.add(entry);
+    syncSubmittedSubscription();
+    return () => {
+      submittedListeners.delete(entry);
+      syncSubmittedSubscription();
+    };
+  };
+  const draftActions = createComposerDraftActions(target);
+  const handle = {
+    replace: draftActions.replace,
+    get scope() {
+      return target().scope;
+    },
+    get key() {
+      return target().key;
+    },
+    get layout() {
+      return editorState().layout;
+    },
+    get isRunning() {
+      return editorState().isRunning;
+    },
+    get isSubmitting() {
+      return editorState().isSubmitting;
+    },
+    get isSubmittingBlocked() {
+      return editorState().isSubmittingBlocked;
+    },
+    get submittingBlockedReason() {
+      return editorState().submittingBlockedReason;
+    },
+    get isEmpty() {
+      return isDraftEmpty(target().getDraft(), target().getAttachmentCount());
+    },
+    get attachmentCount() {
+      return target().getAttachmentCount();
+    },
+    get text() {
+      return target().getDraft().text;
+    },
+    get draft() {
+      return withLegacyDraftFields(
+        draftActions.draft,
+        target().getAttachmentCount()
+      );
+    },
+    get selection() {
+      return target().getSelection();
+    },
+    setText: (next) => {
+      warnDeprecatedComposerMember("setText", "replace");
+      if (legacyAvailable("setText")) replaceText(next);
+    },
+    updateText: (updater) => {
+      warnDeprecatedComposerMember("updateText", "replace");
+      if (legacyAvailable("updateText")) {
+        replaceText(updater(target().getDraft().text));
+      }
+    },
+    clear: () => {
+      warnDeprecatedComposerMember("clear", "replace");
+      if (legacyAvailable("clear")) replaceText("");
+    },
+    insert,
+    setTextEffect: (effect) => controller.setTextEffect(effect),
+    setInputLock: (locked) => controller.setInputLock(locked),
+    addQuote: (text) => {
+      warnDeprecatedComposerMember("addQuote", "replace");
+      if (!legacyAvailable("addQuote")) return;
+      target().addQuote(text);
+      target().focus();
+    },
+    insertMention,
+    removeMention,
+    onSubmitted,
+    focus: () => target().focus(),
+    submit,
+    setSelection,
+    experimental_removeMention: (mention) => {
+      warnDeprecatedComposerMember("experimental_removeMention", "replace");
+      if (!legacyAvailable("experimental_removeMention")) return;
+      removeMentionFrom(mention);
+    },
+    experimental_onSubmitted: (listener) => {
+      warnDeprecatedComposerMember("experimental_onSubmitted", "onSubmitted");
+      return onSubmitted(listener);
+    },
+    experimental_submit: (options) => {
+      warnDeprecatedComposerMember("experimental_submit", "submit");
+      return submit(options);
+    },
+    experimental_setSelection: (selection) => {
+      warnDeprecatedComposerMember("experimental_setSelection", "setSelection");
+      return setSelection(selection);
+    }
+  };
+  Object.defineProperties(handle, {
+    run: {
+      enumerable: false,
+      get: () => {
+        const state = editorState();
+        return { isRunning: state.isRunning, isSubmitting: state.isSubmitting };
+      }
+    },
+    setThreadRowStatus: { enumerable: false, value: () => {
+    } }
+  });
+  return {
+    key,
+    handle,
+    update(next) {
+      controller = next;
+      syncSubmittedSubscription();
+    }
+  };
+}
+
 // src/internal/composer-customization-validation.ts
 var PLUGIN_SLOT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var PLUGIN_MESSAGE_DIRECTIVE_ID_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
@@ -141,6 +657,30 @@ function parseContributionArray(kind, value, onRejected, parse) {
   }
   return parsed;
 }
+function parseMenuItem(entryKind, value) {
+  const entry = value;
+  const id = requireSlotId(entryKind, entry?.id);
+  const icon = requireOptionalString(entryKind, "icon", entry?.icon);
+  const description = requireOptionalString(
+    entryKind,
+    "description",
+    entry?.description
+  );
+  const disabled = entry?.disabled;
+  if (disabled !== void 0 && typeof disabled !== "boolean" && typeof disabled !== "function") {
+    throw new Error(
+      `${entryKind}: "disabled" must be a boolean or function when set`
+    );
+  }
+  return {
+    id,
+    label: requireNonEmptyString(entryKind, "label", entry?.label),
+    ...icon !== void 0 ? { icon } : {},
+    ...description !== void 0 ? { description } : {},
+    ...disabled !== void 0 ? { disabled } : {},
+    run: requireFunction(entryKind, "run", entry?.run)
+  };
+}
 function parseRegions(kind, registration, onRejected) {
   const actions = parseContributionArray(`${kind}.actions`, registration.actions, onRejected, (entryKind, value) => {
     const entry = value;
@@ -168,32 +708,13 @@ function parseRegions(kind, registration, onRejected) {
     `${kind}.plusMenu`,
     registration.plusMenu,
     onRejected,
-    (entryKind, value) => {
-      const entry = value;
-      const id = requireSlotId(entryKind, entry?.id);
-      const icon = requireOptionalString(entryKind, "icon", entry?.icon);
-      const description = requireOptionalString(
-        entryKind,
-        "description",
-        entry?.description
-      );
-      const disabled = entry?.disabled;
-      if (disabled !== void 0 && typeof disabled !== "boolean" && typeof disabled !== "function") {
-        throw new Error(
-          `${entryKind}: "disabled" must be a boolean or function when set`
-        );
-      }
-      return {
-        id,
-        label: requireNonEmptyString(entryKind, "label", entry?.label),
-        ...icon !== void 0 ? { icon } : {},
-        ...description !== void 0 ? { description } : {},
-        ...disabled !== void 0 ? {
-          disabled
-        } : {},
-        run: requireFunction(entryKind, "run", entry?.run)
-      };
-    }
+    parseMenuItem
+  );
+  const sendMenu = parseContributionArray(
+    `${kind}.sendMenu`,
+    registration.sendMenu,
+    onRejected,
+    parseMenuItem
   );
   let richText;
   if (registration.richText !== void 0) {
@@ -236,6 +757,7 @@ function parseRegions(kind, registration, onRejected) {
     ...actions !== void 0 ? { actions } : {},
     ...banners !== void 0 ? { banners } : {},
     ...plusMenu !== void 0 ? { plusMenu } : {},
+    ...sendMenu !== void 0 ? { sendMenu } : {},
     ...richText !== void 0 ? { richText } : {}
   };
 }
@@ -260,7 +782,11 @@ function collectComposerCustomization(registration, seenIds, onRejected) {
     requireUniqueId(kind, seenIds, id);
     return {
       id,
-      ...scopes !== void 0 ? { scopes: [...scopes] } : {},
+      ...scopes !== void 0 ? {
+        scopes: scopes.filter(
+          (scope) => scope !== "side-chat"
+        )
+      } : {},
       ...parseRegions(`${kind}(${id})`, raw ?? {}, onRejected)
     };
   } catch (error) {
@@ -401,7 +927,7 @@ function normalizeExperimentalFileOpenOptions(value) {
 }
 
 // src/internal/plugin-app-collector.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var sidebarFooterCommandSequence = 0;
 var SIDEBAR_FOOTER_ACTION_KEYS = /* @__PURE__ */ new Set([
   "id",
@@ -552,8 +1078,8 @@ function rejectStaleNavPanelKeys(kind, registration) {
     }
   }
 }
-var commandShortcutSchema = z.object({
-  key: z.string().min(1).max(32).refine(
+var commandShortcutSchema = z2.object({
+  key: z2.string().min(1).max(32).refine(
     (key) => ![
       "Alt",
       "Control",
@@ -564,11 +1090,11 @@ var commandShortcutSchema = z.object({
       "Unidentified"
     ].includes(key)
   ),
-  mod: z.boolean().default(false),
-  meta: z.boolean().default(false),
-  control: z.boolean().default(false),
-  alt: z.boolean().default(false),
-  shift: z.boolean().default(false)
+  mod: z2.boolean().default(false),
+  meta: z2.boolean().default(false),
+  control: z2.boolean().default(false),
+  alt: z2.boolean().default(false),
+  shift: z2.boolean().default(false)
 }).strict().refine(
   (shortcut) => shortcut.mod || shortcut.meta || shortcut.control || shortcut.alt || /^F(?:[1-9]|1[0-9]|2[0-4])$/u.test(shortcut.key),
   "Use Command, Control, or Alt with a key, or a function key"
@@ -1079,6 +1605,34 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
 
 // src/testing/app.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
+function testComposerKey(scope) {
+  switch (scope.kind) {
+    case "thread":
+      return `test-composer:thread:${scope.threadId}`;
+    case "queued-message":
+      return `test-composer:queued-message:${scope.threadId}:${scope.queuedMessageId}`;
+    case "new-thread":
+      return `test-composer:new-thread:${scope.projectId ?? ""}`;
+  }
+}
+function testComposerMentionText(mention) {
+  switch (mention.kind) {
+    case "thread":
+      return `@thread:${mention.threadId}`;
+    case "project":
+      return `@project:${mention.projectId}`;
+    case "section":
+      return `@section:${mention.sectionId}`;
+    case "command":
+      return `${mention.trigger}${mention.name}`;
+    case "plugin":
+      return `@${mention.label}`;
+    case "path": {
+      const path = mention.source === "thread-storage" ? `thread-storage:${mention.path}` : mention.path;
+      return `@${path}${mention.entryKind === "directory" && !path.endsWith("/") ? "/" : ""}`;
+    }
+  }
+}
 function createSdkFakeNode(provided, path, calls) {
   const callable = function sdkFakeNode() {
   };
@@ -1610,19 +2164,21 @@ var testPluginSdkApp = {
   },
   useComposer() {
     const composer = useSlotEnv("useComposer").composer;
-    const version = useSyncExternalStore(
+    useSyncExternalStore(
       composer.subscribe,
       composer.getVersionSnapshot,
       composer.getVersionSnapshot
     );
-    return useMemo(
-      () => ({
-        ...composer.api,
-        scope: composer.getScope(),
-        text: composer.getText()
-      }),
-      [composer, version]
+    return composer.api;
+  },
+  useComposers() {
+    const composer = useSlotEnv("useComposers").composer;
+    useSyncExternalStore(
+      composer.subscribe,
+      composer.getVersionSnapshot,
+      composer.getVersionSnapshot
     );
+    return composer.apiList;
   },
   ThreadChat: TestThreadChat,
   Markdown: TestMarkdown,
@@ -1760,13 +2316,13 @@ var testPluginSdkApp = {
       const attachmentCount = composer.getAttachmentCount();
       return {
         scope: composer.getScope(),
-        layout: "expanded",
+        layout: composer.getLayout(),
         draft: {
           text,
           isEmpty: isComposerDraftEmpty(text, attachmentCount),
           attachmentCount
         },
-        run: { isRunning: false, isSubmitting: false }
+        run: composer.getRun()
       };
     }, [composer, version]);
   }
@@ -2171,26 +2727,76 @@ function renderSlot(registration, props, options = {}) {
   const projectId = options.context?.projectId ?? null;
   const threadId = options.context?.threadId ?? null;
   let composerScope = options.composer?.scope ?? (threadId !== null ? { kind: "thread", threadId } : { kind: "new-thread", projectId });
+  let composerSelection = composerScope.kind === "queued-message" ? null : {
+    ...composerScope.kind === "new-thread" && projectId !== null ? { projectId } : {},
+    ...options.composer?.selection
+  };
   let composerText = options.composer?.text ?? "";
-  const composerAttachmentCount = options.composer?.attachmentCount ?? 0;
+  let composerMentions = [
+    ...options.composer?.mentions ?? []
+  ];
+  let composerAttachments = [...options.composer?.attachments ?? []];
+  let composerAttachmentCount = options.composer?.attachmentCount ?? composerAttachments.length;
+  const composerLayout = options.composer?.layout ?? "expanded";
+  const composerIsRunning = options.composer?.isRunning ?? false;
+  const composerIsSubmitting = options.composer?.isSubmitting ?? false;
+  const composerPluginId = options.pluginId ?? "test-plugin";
   let composerVersion = 0;
   const composerListeners = /* @__PURE__ */ new Set();
   const notifyComposerListeners = () => {
     composerVersion += 1;
     for (const listener of composerListeners) listener();
   };
+  const commitComposerDraft = (nextText, nextMentions) => {
+    if (nextText === composerText && nextMentions === composerMentions) return;
+    composerText = nextText;
+    composerMentions = nextMentions;
+    notifyComposerListeners();
+  };
   const commitComposerText = (next) => {
     if (next === composerText) return;
-    composerText = next;
-    notifyComposerListeners();
+    commitComposerDraft(
+      next,
+      reconcileComposerMentions(composerText, next, composerMentions)
+    );
+  };
+  const composerBlockedReason = () => {
+    if (options.composer?.submittingBlockedReason !== void 0) {
+      return options.composer.submittingBlockedReason;
+    }
+    if (composerIsSubmitting) return "Submitting...";
+    return composerText.trim() === "" && composerAttachmentCount === 0 ? "Type a message first." : null;
+  };
+  let composerDraftCache = null;
+  const composerDraft = () => {
+    if (composerDraftCache?.version !== composerVersion) {
+      composerDraftCache = {
+        version: composerVersion,
+        draft: {
+          text: composerText,
+          mentions: composerMentions,
+          attachments: composerAttachments
+        }
+      };
+    }
+    return composerDraftCache.draft;
   };
   const composerLog = {
     get text() {
       return composerText;
     },
+    get draft() {
+      return composerHandle.draft;
+    },
+    get key() {
+      return testComposerKey(composerScope);
+    },
     get scope() {
       return composerScope;
     },
+    get selection() {
+      return composerSelection;
+    },
     get attachmentCount() {
       return composerAttachmentCount;
     },
@@ -2205,26 +2811,88 @@ function renderSlot(registration, props, options = {}) {
     selections: []
   };
   const composerOwnership = { active: true };
+  const composerIsAvailable = () => composerOwnership.active || composerScope.kind !== "queued-message";
   const submissionListeners = /* @__PURE__ */ new Set();
-  const composer = {
+  const composerTarget = {
+    get key() {
+      return testComposerKey(composerScope);
+    },
+    get scope() {
+      return composerScope;
+    },
+    getDraft: composerDraft,
     getAttachmentCount: () => composerAttachmentCount,
-    getScope: () => composerScope,
-    getText: () => composerText,
-    getVersionSnapshot: () => composerVersion,
-    subscribe(listener) {
-      composerListeners.add(listener);
-      return () => composerListeners.delete(listener);
+    getSelection: () => composerSelection,
+    setDraft: (next) => {
+      if (next.attachments !== void 0) {
+        composerAttachments = [...next.attachments];
+        composerAttachmentCount = composerAttachments.length;
+      }
+      commitComposerDraft(next.text, [...next.mentions]);
     },
-    api: {
-      setText(next) {
-        commitComposerText(next);
-      },
-      updateText(updater) {
-        commitComposerText(updater(composerText));
-      },
-      clear() {
-        commitComposerText("");
-      },
+    addQuote(text) {
+      const trimmed = text.replace(/\r\n|\r/gu, "\n").trim();
+      if (trimmed === "") return;
+      const block = trimmed.split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n");
+      commitComposerText(
+        composerText === "" ? `${block}
+` : `${composerText}
+${block}
+`
+      );
+      composerLog.quotes.push(text);
+    },
+    getEditorState: () => {
+      const reason = composerBlockedReason();
+      return {
+        layout: composerLayout,
+        isRunning: composerIsRunning,
+        isSubmitting: composerIsSubmitting,
+        isSubmittingBlocked: reason !== null,
+        submittingBlockedReason: reason,
+        isAttaching: false,
+        attachmentError: null
+      };
+    },
+    subscribeEditorState: () => () => {
+    },
+    insertAtCursor(value, block) {
+      composerTarget.setDraft(
+        appendComposerDraft(composerDraft(), value, block)
+      );
+      return true;
+    },
+    isAvailable: composerIsAvailable,
+    focus() {
+      composerLog.focusCount += 1;
+    },
+    async submit(submitOptions) {
+      composerLog.submits.push(submitOptions);
+      commitComposerDraft("", []);
+      for (const listener of submissionListeners) listener();
+    },
+    async setSelection(selection) {
+      if (composerScope.kind === "queued-message") {
+        throw new Error("This composer has no pickers to set.");
+      }
+      const {
+        projectId: _projectId,
+        environment: _environment,
+        ...rest
+      } = selection;
+      const accepted = composerScope.kind === "thread" ? rest : { ...selection };
+      composerLog.selections.push(accepted);
+      composerSelection = { ...composerSelection, ...accepted };
+      notifyComposerListeners();
+      return composerSelection;
+    }
+  };
+  const composerHandle = createComposerHandleBinding(
+    testComposerKey(composerScope),
+    {
+      pluginId: composerPluginId,
+      target: composerTarget,
+      mentionText: testComposerMentionText,
       setTextEffect(effect) {
         if (!composerOwnership.active) return;
         composerLog.textEffect = effect;
@@ -2235,76 +2903,56 @@ function renderSlot(registration, props, options = {}) {
         composerLog.inputLocked = locked;
         composerLog.inputLockCalls.push(locked);
       },
-      addQuote(text) {
-        const trimmed = text.replace(/\r\n|\r/gu, "\n").trim();
-        if (trimmed !== "") {
-          const block = trimmed.split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n");
-          commitComposerText(
-            composerText === "" ? `${block}
-` : `${composerText}
-${block}
-`
-          );
-          composerLog.quotes.push(text);
-        }
-        composerLog.focusCount += 1;
-      },
-      experimental_onSubmitted(listener) {
+      onSubmitted(listener) {
         submissionListeners.add(listener);
         return () => {
           submissionListeners.delete(listener);
         };
-      },
-      experimental_removeMention({ provider, id }) {
-        for (let index = composerLog.mentions.length - 1; index >= 0; index -= 1) {
-          const mention = composerLog.mentions[index];
-          if (mention?.provider === provider && mention.id === id) {
-            commitComposerText(composerText.replace(mention.label, ""));
-            composerLog.mentions.splice(index, 1);
-          }
-        }
-      },
-      insertMention(mention) {
-        const label = mention.label.trim() || mention.id;
-        const separator = composerText.length === 0 || /\s$/u.test(composerText) ? "" : " ";
-        commitComposerText(`${composerText}${separator}${label} `);
-        composerLog.mentions.push(mention);
-        composerLog.focusCount += 1;
-      },
-      focus() {
-        composerLog.focusCount += 1;
-      },
-      async experimental_submit(options2) {
-        if (!composerOwnership.active) {
-          throw new Error("This composer is no longer active.");
-        }
-        if (composerText.trim() === "") {
-          throw new Error("Type a message before scheduling it.");
-        }
-        if (options2.sendAt !== void 0 && (!Number.isFinite(options2.sendAt) || options2.sendAt <= Date.now())) {
-          throw new Error("Pick a time in the future.");
-        }
-        composerLog.submits.push(options2);
-        commitComposerText("");
-        for (const listener of submissionListeners) listener();
-      },
-      async experimental_setSelection(selection) {
-        if (!composerOwnership.active) {
-          throw new Error("This composer is no longer active.");
-        }
-        if (composerScope.kind === "queued-message" || composerScope.kind === "side-chat") {
-          throw new Error("This composer has no pickers to set.");
-        }
-        const {
-          projectId: _projectId,
-          environment: _environment,
-          ...rest
-        } = selection;
-        const accepted = composerScope.kind === "thread" ? rest : { ...selection };
-        composerLog.selections.push(accepted);
-        return accepted;
       }
     }
+  ).handle;
+  const forgetLoggedMention = ({
+    provider,
+    id
+  }) => {
+    for (let index = composerLog.mentions.length - 1; index >= 0; index -= 1) {
+      const mention = composerLog.mentions[index];
+      if (mention?.provider === provider && mention.id === id) {
+        composerLog.mentions.splice(index, 1);
+      }
+    }
+  };
+  const { insertMention, removeMention, experimental_removeMention } = composerHandle;
+  Object.assign(composerHandle, {
+    insertMention(mention) {
+      insertMention(mention);
+      composerLog.mentions.push(mention);
+    },
+    removeMention(mention) {
+      removeMention(mention);
+      forgetLoggedMention(mention);
+    },
+    experimental_removeMention(mention) {
+      experimental_removeMention(mention);
+      forgetLoggedMention(mention);
+    }
+  });
+  const composer = {
+    api: composerHandle,
+    apiList: [composerHandle],
+    getAttachmentCount: () => composerAttachmentCount,
+    getLayout: () => composerLayout,
+    getRun: () => ({
+      isRunning: composerIsRunning,
+      isSubmitting: composerIsSubmitting
+    }),
+    getScope: () => composerScope,
+    getText: () => composerText,
+    getVersionSnapshot: () => composerVersion,
+    subscribe(listener) {
+      composerListeners.add(listener);
+      return () => composerListeners.delete(listener);
+    }
   };
   const env = {
     rpcClient,
@@ -2382,7 +3030,7 @@ ${block}
   const setRealtimeConnectionState = async (state) => {
     await act(async () => realtimeConnection.setState(state));
   };
-  const setComposerText = async (text) => {
+  const setComposerText2 = async (text) => {
     await act(async () => commitComposerText(text));
   };
   const setComposerScope = async (scope) => {
@@ -2402,7 +3050,7 @@ ${block}
     rpcCalls,
     emitRealtime,
     setRealtimeConnectionState,
-    setComposerText,
+    setComposerText: setComposerText2,
     setComposerScope,
     navigateCalls,
     experimental_fixedTabOpenCalls,
@@ -2413,7 +3061,7 @@ ${block}
     behavior: {
       emitRealtime,
       setRealtimeConnectionState,
-      setComposerText,
+      setComposerText: setComposerText2,
       setComposerScope
     },
     inspection: {