@wix/himalaya-cli 0.1317.0 → 0.1319.0

package/templates/yoga-studio-owner/tier5-src/_shared/aria-chat.ts

@@ -61,10 +61,11 @@ import {
 import {
   ARIA_MAX_ATTACHMENTS,
   ARIA_MAX_IMAGE_BYTES,
+  ARIA_MAX_DOCUMENT_BYTES,
   attachmentLine,
   chipIn,
   imageFileName,
-  normalizeMime,
+  attachmentMime,
   parseDataUri,
   refusalFor,
   sendBlocker,
@@ -480,6 +481,9 @@ export interface AriaChatLabels {
   /** Send refused while a photo is still uploading, or failed to. */
   attachWaitUploading?: Resolvable<string>;
   attachWaitFailed?: Resolvable<string>;
+  /** Send refused by a failed file that cannot be retried (a cold-start chip
+   *  whose source did not survive): Remove is the only control it offers. */
+  attachWaitRemove?: Resolvable<string>;
   /** Send refused with photos and no words. The service requires message text
    *  on every turn, so a photo alone is not a sendable message. */
   attachNeedsText?: Resolvable<string>;
@@ -535,7 +539,7 @@ export interface AriaDictationOptions {
 export interface AriaAttachmentPorts {
   /** Let the owner pick (or take) one photo. Resolves the image as a `data:`
    *  URI, or null when they cancelled. */
-  pick(source: "library" | "camera"): Promise<{ dataUri: string; name?: string; mimeType?: string } | null>;
+  pick(source: "library" | "camera" | "document"): Promise<{ dataUri: string; name?: string; mimeType?: string } | null>;
   /** PUT `base64` to a pre-signed url with `contentType`, carrying NO user
    *  credentials — the url authorizes itself. */
   put(url: string, base64: string, contentType: string): Promise<{ ok: boolean; status: number }>;
@@ -1652,23 +1656,28 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
   const attachUploadingText = () => res(o.labels?.attachUploading ?? "Uploading…");
   const attachFailedText = () => res(o.labels?.attachFailed ?? "Couldn't upload");
   const chipLabels = () => ({ uploading: attachUploadingText(), failed: attachFailedText() });
-  const refusalText = (why: "type" | "size" | "count"): string =>
+  const refusalText = (why: "type" | "size" | "count", maxBytes = ARIA_MAX_IMAGE_BYTES): string =>
     why === "count"
-      ? o.labels?.attachTooMany?.(ARIA_MAX_ATTACHMENTS) ?? `You can attach up to ${ARIA_MAX_ATTACHMENTS} photos.`
+      ? o.labels?.attachTooMany?.(ARIA_MAX_ATTACHMENTS) ?? `You can attach up to ${ARIA_MAX_ATTACHMENTS} files.`
       : why === "size"
-        ? o.labels?.attachTooLarge?.(ARIA_MAX_IMAGE_BYTES / (1024 * 1024))
-          ?? `That photo is too large to attach (up to ${ARIA_MAX_IMAGE_BYTES / (1024 * 1024)} MB).`
+        ? o.labels?.attachTooLarge?.(maxBytes / (1024 * 1024))
+          ?? `That file is too large to attach (up to ${maxBytes / (1024 * 1024)} MB).`
         : res(o.labels?.attachUnsupported ?? "That file type can't be attached.");
-  const waitUploadingText = () => res(o.labels?.attachWaitUploading ?? "Wait for your photo to finish uploading.");
-  const waitFailedText = () => res(o.labels?.attachWaitFailed ?? "Retry or remove the photo that didn't upload.");
-  const needsTextText = () => res(o.labels?.attachNeedsText ?? "Add a message to send with your photo.");
+  const waitUploadingText = () => res(o.labels?.attachWaitUploading ?? "Wait for your file to finish uploading.");
+  const waitFailedText = () => res(o.labels?.attachWaitFailed ?? "Retry or remove the file that didn't upload.");
+  const waitRemoveText = () => res(o.labels?.attachWaitRemove ?? "Remove the file that didn't upload, then add it again.");
+  /** The failed-file notice must name only a control the chips offer: "Retry"
+   *  while any failed chip can still retry, otherwise "Remove". */
+  const failedNotice = (): string =>
+    chips.some((c) => c.state === "failed" && !c.retryHidden) ? waitFailedText() : waitRemoveText();
+  const needsTextText = () => res(o.labels?.attachNeedsText ?? "Add a message to send with your file.");
   /** Clear the status line if what it says is an attachment notice, and only
    *  then. Every notice is advice about the composer's photos, so once the owner
    *  acts on them it is stale — but the same line also carries "Aria is
    *  typing…", which a photo edit must never erase. */
   const withoutNotice = <T extends { statusText: string }>(s: T): T => {
-    const notices = [waitUploadingText(), waitFailedText(), needsTextText(),
-      refusalText("type"), refusalText("size"), refusalText("count")];
+    const notices = [waitUploadingText(), waitFailedText(), waitRemoveText(), needsTextText(),
+      refusalText("type"), refusalText("size"), refusalText("size", ARIA_MAX_DOCUMENT_BYTES), refusalText("count")];
     return s.statusText && notices.includes(s.statusText) ? { ...s, statusText: "" } : s;
   };
   const toolFailedText = () => res(o.labels?.toolFailed ?? `${assistant()} couldn't finish that. Try again.`);
@@ -2023,16 +2032,20 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     chipsSeeded = true;
     const persisted = Array.isArray(s.attachments) ? s.attachments : [];
     // An upload does not survive the process that ran it, so a chip persisted
-    // mid-upload would say "Uploading…" forever. It still holds its bytes, so it
-    // comes back as FAILED — with the retry control — rather than being dropped.
+    // mid-upload would say "Uploading…" forever. Restore it as failed; only a
+    // chip with retained inline bytes can offer Retry until the file-backed follow-up.
     chips = persisted
       .filter((c) => c && typeof c.id === "string")
-      .map((c) => (c.state === "uploading" ? chipIn(c, "failed", chipLabels()) : c));
+      .map((c) => {
+        const chip = chipIn(c, c.state === "uploading" ? "failed" : c.state, chipLabels(), c.ref);
+        // Inline bytes were worker-owned. A cold-start document or large image
+        // has no source left: keep Remove available, never offer a dead Retry.
+        return chip.state === "failed" && !chip.thumbUrl ? { ...chip, retryHidden: true } : chip;
+      });
     for (const c of chips) {
       const n = Number(/^att-(\d+)$/.exec(c.id)?.[1] ?? 0);
       if (n > chipSeq) chipSeq = n;
-      // A rehydrated chip's bytes are whatever it kept inline. A large photo kept
-      // none, so its retry fails honestly rather than sending nothing.
+      // A rehydrated chip can retry only the source it kept inline.
       if (c.thumbUrl && !chipBytes.has(c.id)) chipBytes.set(c.id, c.thumbUrl);
     }
   };
@@ -2044,21 +2057,21 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     if (!chips.length) return null;
     const blocker = sendBlocker(chips);
     if (blocker === "uploading") return { ...s, statusText: waitUploadingText(), error: "" };
-    if (blocker === "failed") return { ...s, statusText: waitFailedText(), error: "" };
+    if (blocker === "failed") return { ...s, statusText: failedNotice(), error: "" };
     if (!content) return { ...s, statusText: needsTextText(), error: "" };
     return null;
   };
 
   /** Keep a "wait for your photo" notice true to the chips as they are NOW. An
-   *  upload that FAILED while Send was held on "Wait for your photo to finish
+   *  upload that FAILED while Send was held on "Wait for your file to finish
    *  uploading" must say to retry or remove it instead, and one that landed,
    *  with nothing else pending, clears it. Any other status line (the typing
    *  line above all) is left alone. */
   const refreshWaitNotice = (s: AriaChatState): AriaChatState => {
-    const waiting = [waitUploadingText(), waitFailedText()];
+    const waiting = [waitUploadingText(), waitFailedText(), waitRemoveText()];
     if (!s.statusText || !waiting.includes(s.statusText)) return s;
     const blocker = sendBlocker(chips);
-    const next = blocker === "uploading" ? waitUploadingText() : blocker === "failed" ? waitFailedText() : "";
+    const next = blocker === "uploading" ? waitUploadingText() : blocker === "failed" ? failedNotice() : "";
     return next === s.statusText ? s : { ...s, statusText: next };
   };
 
@@ -3794,8 +3807,8 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       const atCategories = { ...m, open: true, provider: null, query: "", items: [], itemsLoading: false, itemsFailed: "" };
       // Listed once per business. A failed list is asked again: the failure
       // may have been the network, and the next open is the retry.
-      if (m.providers !== null) { setMention(atCategories); return s; }
-      if (m.providersLoading) { setMention(atCategories); return s; }
+      if (m.providers !== null) { setMention(atCategories); return committed ?? s; }
+      if (m.providersLoading) { setMention(atCategories); return committed ?? s; }
       const site = m.site;
       setMention({ ...atCategories, providersLoading: true, providersFailed: "" });
       let providers: MentionProvider[] | null = null;
@@ -4112,7 +4125,8 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // picker whose result will be thrown away wastes the owner's time.
       if (chips.length >= ARIA_MAX_ATTACHMENTS) return { ...s, statusText: refusalText("count"), error: "" };
       const raw = typeof arg === "string" ? arg : firstString(arg?.source, arg?.value);
-      const source = raw.trim().toLowerCase() === "camera" ? "camera" : "library";
+      const source = raw.trim().toLowerCase() === "document" ? "document"
+        : raw.trim().toLowerCase() === "camera" ? "camera" : "library";
       // The picker is open for as long as the owner takes, and a poll, a reply or
       // another action can commit a NEWER state meanwhile. Returning `{ ...s }`
       // afterwards would put this pre-picker snapshot back over it: an older
@@ -4124,17 +4138,18 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       let picked: Awaited<ReturnType<AriaAttachmentPorts["pick"]>>;
       try {
         picked = await ports.pick(source);
-      } catch {
+      } catch (error) {
+        if (/too large|size limit/i.test(String(error))) return { ...latest(), statusText: refusalText("size", source === "document" ? ARIA_MAX_DOCUMENT_BYTES : ARIA_MAX_IMAGE_BYTES), error: "" };
         // A picker that could not open is not the owner's fault and there is no
         // file to talk about; say nothing rather than something misleading.
-        return latest();
+        return withoutNotice(latest());
       }
       if (!picked || !picked.dataUri) return latest();   // cancelled
       const parsed = parseDataUri(picked.dataUri);
-      const mimeType = normalizeMime(picked.mimeType || parsed?.mimeType || "");
+      const mimeType = attachmentMime(picked.mimeType || parsed?.mimeType || "", picked.name);
       // Re-checked after the await: other picks may have landed meanwhile.
       const refused = refusalFor(parsed, mimeType, chips.length);
-      if (refused) return { ...latest(), statusText: refusalText(refused), error: "" };
+      if (refused) return { ...latest(), statusText: refusalText(refused, mimeType.startsWith("image/") ? ARIA_MAX_IMAGE_BYTES : ARIA_MAX_DOCUMENT_BYTES), error: "" };
       chipSeq += 1;
       const id = `att-${chipSeq}`;
       chipBytes.set(id, picked.dataUri);
@@ -4143,7 +4158,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         name: imageFileName(mimeType, chipSeq, picked.name),
         mimeType,
         // Only a small image rides the state as its own thumbnail; see `chipBytes`.
-        thumbUrl: picked.dataUri.length <= THUMB_INLINE_MAX ? picked.dataUri : "",
+        thumbUrl: mimeType.startsWith("image/") && picked.dataUri.length <= THUMB_INLINE_MAX ? picked.dataUri : "",
       }, "uploading", chipLabels());
       chips = [...chips, chip];
       startUpload(chip);
@@ -4202,7 +4217,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     retryAttachment: (s, arg) => {
       const id = chipIdOf(arg);
       const current = chips.find((c) => c.id === id);
-      if (!current || current.state !== "failed") return s;
+      if (!current || current.state !== "failed" || (!chipBytes.get(id) && !current.thumbUrl)) return s;
       // A NEW id for the new attempt, in the same place in the strip. Keeping the
       // old one would let the first attempt's outcome, if it is still in the air,
       // settle this one.
@@ -4421,8 +4436,21 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       await probeDictation();
       return gated(r.listening && !dictationLive ? { ...r, listening: false } : r);
     },
-    submit: (s, arg) => impl.submit(s, arg).then(gated),
-    submitPrompt: (s, arg) => impl.submitPrompt(s, arg).then(gated),
+    submit: async (s, arg) => {
+      const revision = draftSeq;
+      const next = await impl.submit(s, arg);
+      // Refusals preserve a draft; an edit while the async reducer resolved
+      // belongs to the owner, including consuming a selected mention trigger.
+      // Preserve the send result and its pending turn/poll; only rebase the draft.
+      return gated(revision !== draftSeq && next.input === s.input && committed
+        ? { ...next, input: committed.input } : next);
+    },
+    submitPrompt: async (s, arg) => {
+      const revision = draftSeq;
+      const next = await impl.submitPrompt(s, arg);
+      return gated(revision !== draftSeq && next.input === s.input && committed
+        ? { ...next, input: committed.input } : next);
+    },
     newChat: (s) => impl.newChat(s).then(gated),
     typing: (s, arg) => gated(impl.typing(s, arg)),
     tick: (s) => impl.tick(s).then((r) => (r ? gated(r) : r)),

package/templates/yoga-studio-owner/tier5-src/himi-owner-lite-aria/index.ts

@@ -28,7 +28,7 @@ import { defineService } from "@himalaya/state";
 import { open } from "@himalaya/open-url";
 import { writeText } from "@himalaya/clipboard";
 import { availability, recognizeOnce, stop as stopSpeech } from "@himalaya/speech";
-import { capturePhoto } from "@himalaya/camera";
+import { capturePhoto, pickDocument } from "@himalaya/camera";
 import { put } from "@himalaya/presigned-upload";
 import { alert } from "@himalaya/ui";
 import { auth } from "@himalaya/wix-platform";
@@ -250,12 +250,13 @@ const core = createAriaChat({
     widgetItemsUnavailable: () => copyParam("ownerAria.widget.itemsUnavailable", "Items aren't available here."),
     attachUploading: () => copyParam("ownerAria.attach.uploading", "Uploading…"),
     attachFailed: () => copyParam("ownerAria.attach.failed", "Couldn't upload"),
-    attachTooMany: (max) => copyTemplate("ownerAria.attach.tooMany", "You can attach up to {max} photos.", { max }),
+    attachTooMany: (max) => copyTemplate("ownerAria.attach.tooMany", "You can attach up to {max} files.", { max }),
     attachUnsupported: () => copyParam("ownerAria.attach.unsupported", "That file type can't be attached."),
-    attachTooLarge: (mb) => copyTemplate("ownerAria.attach.tooLarge", "That photo is too large to attach (up to {mb} MB).", { mb }),
-    attachWaitUploading: () => copyParam("ownerAria.attach.waitUploading", "Wait for your photo to finish uploading."),
-    attachWaitFailed: () => copyParam("ownerAria.attach.waitFailed", "Retry or remove the photo that didn't upload."),
-    attachNeedsText: () => copyParam("ownerAria.attach.needsText", "Add a message to send with your photo."),
+    attachTooLarge: (mb) => copyTemplate("ownerAria.attach.tooLarge", "That file is too large to attach (up to {mb} MB).", { mb }),
+    attachWaitUploading: () => copyParam("ownerAria.attach.waitUploading", "Wait for your file to finish uploading."),
+    attachWaitFailed: () => copyParam("ownerAria.attach.waitFailed", "Retry or remove the file that didn't upload."),
+    attachWaitRemove: () => copyParam("ownerAria.attach.waitRemove", "Remove the file that didn't upload, then add it again."),
+    attachNeedsText: () => copyParam("ownerAria.attach.needsText", "Add a message to send with your file."),
     toolFailed: () => copyParam("ownerAria.toolFailed", "Aria couldn't finish that. Try again."),
   },
   clientTools: { confirm: confirmWithOwner, userAgent },
@@ -305,6 +306,10 @@ const core = createAriaChat({
   // which go to a self-authorizing url with no Wix credential attached.
   attachments: {
     pick: async (source) => {
+      if (source === "document") {
+        const file = await pickDocument();
+        return file ? { dataUri: file.uri, name: file.name, mimeType: file.mime } : null;
+      }
       const asset = await capturePhoto({ source, maxEdgePixels: 2048 });
       return asset ? { dataUri: asset.uri, mimeType: asset.mime } : null;
     },
@@ -318,6 +323,92 @@ const core = createAriaChat({
   },
 });
 
+// Focused native TextFields keep their local non-empty edit rather than adopting
+// worker normalization (the shared shouldAdoptWorkerValue rule). Remember only
+// prefixes where THIS draft actually selected a reference, so later editor echoes and
+// the Form.message submission cannot restore those triggers into the wire text.
+// Email addresses and newly authored @ characters are never blanket-stripped.
+let mentionTriggerPrefixes: string[] = [];
+let pendingMentionTrigger: { rawPrefix: string; prefix: string } | null = null;
+let mentionDraftRevision = 0;
+let previousMentionRaw = "";
+// Set by a selection that consumed a typed trigger: the normalized draft the
+// worker now holds. A field that blurs adopts that value WITHOUT dispatching
+// typing, so the next keystroke is an edit of it, not of previousMentionRaw.
+// The first typing after a selection whose raw value is byte-identical to the
+// pre-selection one cannot be an edit of the focused raw text (nothing changed),
+// so it is read as an edit of the adopted draft: that field holds no consumed
+// marker any more, and a standalone @ there is a new trigger.
+let adoptedMentionDraft: string | null = null;
+function reconcileMentionDraft(raw: string): string {
+  // Move consumed trigger positions with an edit anywhere in the focused field.
+  // A replaced/deleted trigger loses its marker, so newly authored @ text stays literal.
+  let start = 0;
+  while (start < previousMentionRaw.length && start < raw.length && previousMentionRaw[start] === raw[start]) start += 1;
+  let suffix = 0;
+  while (suffix < previousMentionRaw.length - start && suffix < raw.length - start
+    && previousMentionRaw[previousMentionRaw.length - suffix - 1] === raw[raw.length - suffix - 1]) suffix += 1;
+  const end = previousMentionRaw.length - suffix;
+  const delta = raw.length - previousMentionRaw.length;
+  const move = (position: number): number | null => position < start ? position : position >= end ? position + delta : null;
+  mentionTriggerPrefixes = mentionTriggerPrefixes.flatMap(prefix => {
+    let position = move(prefix.length);
+    // A whole-draft replacement ("Ask @" → "New @") shares only whitespace and the @
+    // with the old text, so the common suffix lines the NEW @ up with the old marker.
+    // When every word before the marker was replaced, its context is gone: the @ is
+    // newly authored and must stay (and may open the picker again).
+    if (position !== null && start === 0 && prefix.length >= end && prefix.trim()
+      && !previousMentionRaw.slice(end, prefix.length).trim()) return [];
+    // Coalesced edits may add text on both sides of the marker. Keep it when
+    // its complete previous context still occurs exactly once in the new value.
+    if (position === null && prefix) {
+      const anchor = `${prefix}@`; const found = raw.indexOf(anchor);
+      if (found >= 0 && raw.indexOf(anchor, found + 1) < 0) position = found + prefix.length;
+    }
+    // A coalesced focused-field edit can replace context on both sides of a
+    // selected marker. If this is the sole consumed marker and the new draft
+    // has one standalone @, its position is unambiguous even without the old
+    // prefix. Email addresses and authored @suffixes are never candidates.
+    if (position === null && mentionTriggerPrefixes.length === 1) {
+      const candidates = [...raw.matchAll(/(^|\s)@(?=\s|$)/g)].map(match => match.index! + match[1].length);
+      if (candidates.length === 1) position = candidates[0];
+    }
+    // Only the standalone trigger that opened the picker is consumed. Adding
+    // a literal suffix (or joining it to the preceding word) authors ordinary
+    // @ text even when the focused editor retains the selected trigger.
+    const standalone = position !== null && raw[position] === "@"
+      && (position === 0 || /\s/.test(raw[position - 1]))
+      && (position + 1 === raw.length || /\s/.test(raw[position + 1]));
+    return standalone ? [raw.slice(0, position!)] : [];
+  });
+  if (pendingMentionTrigger) {
+    const position = move(pendingMentionTrigger.rawPrefix.length);
+    const standalone = position !== null && raw[position] === "@"
+      && (position === 0 || /\s/.test(raw[position - 1]))
+      && (position + 1 === raw.length || /\s/.test(raw[position + 1]));
+    pendingMentionTrigger = standalone
+      ? { rawPrefix: raw.slice(0, position!), prefix: raw.slice(0, position!) } : null;
+    if (pendingMentionTrigger) {
+      for (const prefix of [...mentionTriggerPrefixes].sort((a, b) => b.length - a.length)) {
+        if (prefix.length < pendingMentionTrigger.rawPrefix.length) pendingMentionTrigger.prefix = pendingMentionTrigger.prefix.slice(0, prefix.length) + pendingMentionTrigger.prefix.slice(prefix.length + 1);
+      }
+    }
+  }
+  previousMentionRaw = raw;
+  let text = raw;
+  for (const prefix of [...mentionTriggerPrefixes].sort((a, b) => b.length - a.length)) {
+    text = text.slice(0, prefix.length) + text.slice(prefix.length + 1);
+  }
+  return text;
+}
+function reconciledMentionArg(arg?: AriaActionArg): AriaActionArg | undefined {
+  if (typeof arg === "string") return reconcileMentionDraft(arg);
+  if (!arg) return arg;
+  const keys: Array<"message" | "text" | "value" | "intent" | "id"> = ["message", "text", "value", "intent", "id"];
+  const key = keys.find(k => typeof arg[k] === "string" && arg[k]);
+  return key ? { ...arg, [key]: reconcileMentionDraft(String(arg[key])) } : arg;
+}
+
 const svc = defineService<AriaChatState, {
   load: (s: AriaChatState, arg?: AriaActionArg) => Promise<AriaChatState>;
   submit: (s: AriaChatState, arg?: AriaActionArg) => Promise<AriaChatState>;
@@ -374,13 +465,51 @@ const svc = defineService<AriaChatState, {
   state: core.initialState,
   actions: {
     // `load` is the onAppear dispatch, so it is where the copy pack arrives.
-    load: (s, arg) => { stashCopy(arg); stashTargets(arg); stashRealtimeUrl(arg); return core.load(s); },
-    submit: core.submit,
-    submitPrompt: core.submitPrompt,
-    newChat: core.newChat,
+    load: (s, arg) => { mentionDraftRevision += 1; mentionTriggerPrefixes = []; pendingMentionTrigger = null; previousMentionRaw = ""; adoptedMentionDraft = null; stashCopy(arg); stashTargets(arg); stashRealtimeUrl(arg); return core.load(s); },
+    submit: async (s, arg) => {
+      const normalized = reconciledMentionArg(arg);
+      const previousPrefixes = mentionTriggerPrefixes; const previousTrigger = pendingMentionTrigger;
+      const revision = mentionDraftRevision;
+      const next = await core.submit(s, normalized);
+      // A refusal keeps this draft; a later keystroke/new-chat belongs to its own.
+      if (revision === mentionDraftRevision) {
+        if (next.input && next.input === s.input) { mentionTriggerPrefixes = previousPrefixes; pendingMentionTrigger = previousTrigger; }
+        else { mentionTriggerPrefixes = []; pendingMentionTrigger = null; previousMentionRaw = ""; adoptedMentionDraft = null; }
+      }
+      return next;
+    },
+    submitPrompt: async (s, arg) => {
+      const previousPrefixes = mentionTriggerPrefixes; const previousTrigger = pendingMentionTrigger;
+      const revision = mentionDraftRevision;
+      const next = await core.submitPrompt(s, arg);
+      if (revision === mentionDraftRevision) {
+        if (next.input && next.input === s.input) { mentionTriggerPrefixes = previousPrefixes; pendingMentionTrigger = previousTrigger; }
+        else { mentionTriggerPrefixes = []; pendingMentionTrigger = null; previousMentionRaw = ""; adoptedMentionDraft = null; }
+      }
+      return next;
+    },
+    newChat: (s) => { mentionDraftRevision += 1; mentionTriggerPrefixes = []; pendingMentionTrigger = null; previousMentionRaw = ""; adoptedMentionDraft = null; return core.newChat(s); },
     // The composer's onChange. Mirrors the draft into state so `submit` can
     // empty it and the field actually clears.
-    typing: core.typing,
+    typing: (s, arg) => {
+      mentionDraftRevision += 1;
+      const raw = typeof arg === "string" ? arg : ([arg?.value, arg?.text, arg?.message].find((v): v is string => typeof v === "string") ?? "");
+      if (adoptedMentionDraft !== null) {
+        if (raw === previousMentionRaw) { mentionTriggerPrefixes = []; previousMentionRaw = adoptedMentionDraft; }
+        adoptedMentionDraft = null;
+      }
+      const next = core.typing(s, { value: reconcileMentionDraft(raw) });
+      // A standalone @ asks for a reference; emails and embedded @ characters
+      // remain ordinary text. A successful selection consumes its trigger.
+      if (next.input !== s.input && /(?:^|\s)@$/.test(next.input) && !next.mention.openHidden) {
+        // Keep the fragment editable until a reference is selected. Cancelling
+        // the picker must not turn a literal @example.com into example.com.
+        pendingMentionTrigger = { rawPrefix: raw.slice(0, -1), prefix: next.input.slice(0, -1) };
+        void svc.mentionOpen();
+        return next;
+      }
+      return next;
+    },
     // Named by the `_poll` directive above. A name that does not resolve here is
     // a `poll-action-missing` error in `himi test --content`.
     tick: core.tick,
@@ -419,11 +548,23 @@ const svc = defineService<AriaChatState, {
     // chips above the composer. Every one is named by the descriptor, so every
     // one has to be exported here — see the note on the picker family above.
     mentionOpen: core.mentionOpen,
-    mentionClose: core.mentionClose,
+    mentionClose: (s) => { pendingMentionTrigger = null; return core.mentionClose(s); },
     mentionBack: core.mentionBack,
     mentionProvider: core.mentionProvider,
     mentionQuery: core.mentionQuery,
-    mentionPick: core.mentionPick,
+    mentionPick: (s, arg) => {
+      const next = core.mentionPick(s, arg);
+      const trigger = pendingMentionTrigger;
+      if (trigger && !s.mention.hidden && next.mention.hidden && next.input.startsWith(`${trigger.prefix}@`)) {
+        mentionDraftRevision += 1;
+        pendingMentionTrigger = null;
+        if (!mentionTriggerPrefixes.includes(trigger.rawPrefix)) mentionTriggerPrefixes.push(trigger.rawPrefix);
+        const normalized = next.input.slice(0, trigger.prefix.length) + next.input.slice(trigger.prefix.length + 1);
+        adoptedMentionDraft = normalized;
+        return core.typing(next, { value: normalized });
+      }
+      return next;
+    },
     mentionRemove: core.mentionRemove,
     // The composer's photos. `attachmentSettled` is dispatched by the upload
     // itself (see `attachments.settled` above), never by the descriptor.