@wix/himalaya-cli 0.1250.0 → 0.1252.0

package/templates/portfolio-creative-owner/tier5-src/_shared/aria-chat.ts

@@ -72,8 +72,19 @@ import {
 import { runClientToolExchange, type AriaClientTools } from "./aria-client-tools.js";
 import { proseOfParts, scanEnvelopes, stripHidden } from "./aria-widgets.js";
 import { isWebUrl, stripMarkdown } from "./aria-widget-model.js";
-import { NO_WIDGET, activeWidgetOf, asyncAdvanced, type SubtreeSlot, type WidgetOptionRow, type WidgetView }
-  from "./aria-widget-view.js";
+import {
+  DEFAULT_QUESTIONNAIRE_COPY,
+  NO_WIDGET,
+  activeWidgetOf,
+  asyncAdvanced,
+  questionnaireAnswers,
+  questionnaireSynced,
+  sameQuestionnaire,
+  type QuestionnaireCopy,
+  type SubtreeSlot,
+  type WidgetOptionRow,
+  type WidgetView,
+} from "./aria-widget-view.js";
 import { substituteSelection } from "./aria-widget-model.js";
 import { MENTION_PAGE_SIZE, allowlisted, emptyMentionModel, mentionView,
   type MentionItemRow, type MentionLabels, type MentionModel, type MentionProvider, type MentionView } from "./aria-mentions.js";
@@ -326,6 +337,15 @@ export interface AriaChatLabels {
   selectionLimit?: (max: number) => string;
   /** Shown under a questionnaire while a required answer is missing. */
   answersIncomplete?: string;
+  /** A questionnaire's place, e.g. "2 of 3". Only shown with two or more
+   *  questions. */
+  questionProgress?: (current: number, total: number) => string;
+  /** A questionnaire's submit, when the payload's own button has no label. */
+  questionnaireSubmit?: Resolvable<string>;
+  /** Shown when the owner taps an option whose destination is a screen of the
+   *  native Wix app that this app does not have, and the payload gave no
+   *  explanation of its own. */
+  notSupported?: Resolvable<string>;
   /** Shown instead of a raw transport error when this HOST cannot reach Wix at
    *  all — it carries no Wix app binding to sign the chat-service call with.
    *  See `isWixAccountUnreachable`, and note what it is NOT: a signed-out user. */
@@ -349,6 +369,10 @@ export interface AriaChatLabels {
   /** Shown when one provider's items could not be fetched. Takes the
    *  category's label. */
   mentionItemsFailed?: (category: string) => string;
+  /** Shown when a response widget's item provider cannot be queried. */
+  widgetItemsFailed?: Resolvable<string>;
+  /** Shown when this host cannot reach Wix's item provider service. */
+  widgetItemsUnavailable?: Resolvable<string>;
   /** Attachment copy — see `AriaChatOptions.attachments`. Chip states: */
   attachUploading?: Resolvable<string>;
   attachFailed?: Resolvable<string>;
@@ -509,7 +533,7 @@ export interface AriaChatOptions {
  *  its new BOOLEAN there on iOS and Android, and the native marshaller merges
  *  args over params — so anything reading it must cope with a non-string.
  *  `optionValue` is the key a caller should use when it means the option. */
-export type AriaActionArg = string | { message?: string; text?: string; value?: unknown; optionValue?: string; id?: string; url?: string; intent?: string; source?: string; ok?: unknown; ref?: string } | undefined;
+export type AriaActionArg = string | { message?: string; text?: string; value?: unknown; optionValue?: string; id?: string; url?: string; intent?: string; section?: string; step?: string; source?: string; ok?: unknown; ref?: string } | undefined;
 
 /** The first of these fields that is actually a non-empty string.
  *
@@ -1291,8 +1315,13 @@ export interface AriaChatCore {
    *  first. The mode is known where the payload is, so the choice belongs
    *  here. */
   widgetPick(s: AriaChatState, arg?: AriaActionArg): AriaChatState;
-  /** Answer one QUESTIONNAIRE question. */
+  /** Type into a QUESTIONNAIRE question's free-text field. `id` names the
+   *  question; the text rides the control's own `value`. */
   widgetAnswer(s: AriaChatState, arg?: AriaActionArg): AriaChatState;
+  /** Move through a QUESTIONNAIRE one question at a time: `step` is `"next"`
+   *  or `"back"`. Next refuses while the question on screen is required and
+   *  unanswered — the same rule its greyed twin shows. */
+  widgetStep(s: AriaChatState, arg?: AriaActionArg): AriaChatState;
   /** The composer's mic: open the recognizer and show "Listening…". Returns at
    *  once; the transcript arrives later through `dictated`. */
   dictate(s: AriaChatState): AriaChatState;
@@ -1361,6 +1390,15 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     o.labels?.answersIncomplete ?? "Answer the required questions to continue.";
   const limitReachedText = (max: number) =>
     o.labels?.selectionLimit?.(max) ?? `You can choose up to ${max}.`;
+  const questionnaireCopy = (): QuestionnaireCopy => ({
+    progress: o.labels?.questionProgress ?? DEFAULT_QUESTIONNAIRE_COPY.progress,
+    incomplete: answersIncompleteText(),
+    submit: o.labels?.questionnaireSubmit
+      ? res(o.labels.questionnaireSubmit)
+      : DEFAULT_QUESTIONNAIRE_COPY.submit,
+  });
+  const notSupportedText = () =>
+    (o.labels?.notSupported ? res(o.labels.notSupported) : "") || "That isn't available in this app yet.";
   // States the fact and stops. It deliberately gives no instruction, because
   // there is none the owner could follow: they are signed in, and the thing that
   // is missing is the app's own Wix binding. "Here" is doing real work — it says
@@ -1372,6 +1410,8 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     o.labels?.dictationEmpty ?? "Didn't catch that. Check microphone access and try again.",
   );
   const dictationFailedText = () => res(o.labels?.dictationFailed ?? "Dictation isn't available right now.");
+  const widgetItemsFailedText = () => res(o.labels?.widgetItemsFailed ?? "Couldn't load these items.");
+  const widgetItemsUnavailableText = () => res(o.labels?.widgetItemsUnavailable ?? "Items aren't available here.");
   const attachUploadingText = () => res(o.labels?.attachUploading ?? "Uploading…");
   const attachFailedText = () => res(o.labels?.attachFailed ?? "Couldn't upload");
   const chipLabels = () => ({ uploading: attachUploadingText(), failed: attachFailedText() });
@@ -1989,16 +2029,119 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
    *  from what the service sent. */
   const carrySelection = (next: WidgetView, prev?: WidgetView): WidgetView => {
     if (!prev || prev.hidden || next.hidden) return next;
+    // A new assistant row can ask the exact same questionnaire again. Its
+    // shape is not enough to identify the ask; only carry edits while the
+    // transcript row itself is unchanged.
+    if (!next.sourceMessageId || prev.sourceMessageId !== next.sourceMessageId) return next;
     if (prev.kind !== next.kind) return next;
+    // A questionnaire carries MORE than a selection — every answer, typed text
+    // and which question is on screen — and its `options` are only the CURRENT
+    // question's choices, so the comparison below would call an owner on
+    // question two a different ask and throw all of it away on the next poll.
+    if (next.kind === "QUESTIONNAIRE") {
+      return sameQuestionnaire(prev, next)
+        ? questionnaireSynced({ ...next, questions: prev.questions }, prev.questionIndex,
+            questionnaireCopy(), !prev.answersTextHidden)
+        : next;
+    }
+    // ITEMS_SELECTION's payload supplies a provider key, not option rows. Keep
+    // the fetched page (and its terminal error state) as the transcript is
+    // re-read; otherwise every poll would replace it with the empty loading
+    // placeholder and issue the same provider request again.
+    if (next.kind === "ITEMS_SELECTION" && prev.providerKey === next.providerKey && !prev.itemsLoading) {
+      return reselect({ ...next, options: prev.options, itemsLoading: false, itemsLoadingHidden: true,
+        itemsError: prev.itemsError, itemsErrorHidden: prev.itemsErrorHidden,
+        itemsEmpty: prev.itemsEmpty }, prev.options);
+    }
     if (prev.options.length !== next.options.length) return next;
     for (let i = 0; i < next.options.length; i++) {
       if (prev.options[i].value !== next.options[i].value) return next;
     }
-    if (!prev.options.some((o, i) => o.selected !== next.options[i].selected)) return next;
+    // The line explaining an option that could not open is the answer to a
+    // tap, and a poll is not a reason to take it back.
+    const kept = prev.notice ? { ...next, notice: prev.notice, noticeHidden: prev.noticeHidden } : next;
+    if (!prev.options.some((o, i) => o.selected !== next.options[i].selected)) return kept;
     const options = next.options.map((o, i) => ({ ...o, selected: prev.options[i].selected }));
-    return reselect({ ...next, options }, options);
+    return reselect({ ...kept, options }, options);
+  };
+
+  /** Fetch the provider-backed rows after a transcript reveals an
+   *  ITEMS_SELECTION. This runs in the worker, through the same Wix API
+   *  capability used by the mention picker. A provider failure is shown inside
+   *  the widget and never turns into an empty list that looks like success. */
+  const withWidgetItems = async (s: AriaChatState): Promise<AriaChatState> => {
+    const w = s.widget;
+    if (w.kind !== "ITEMS_SELECTION" || !w.itemsLoading || !w.providerKey) return s;
+
+    let options: WidgetOptionRow[] = [];
+    let error = "";
+    try {
+      const installed = await listInstalledProviders();
+      const provider = (installed.providers ?? []).find((candidate) =>
+        typeof candidate?.key === "string" && candidate.key.trim() === w.providerKey);
+      if (!provider) {
+        error = widgetItemsFailedText();
+      } else {
+        const pageSize = 50;
+        let offset = 0;
+        let cursor = "";
+        const seenCursors = new Set<string>();
+        const items: ReturnType<typeof itemsOf> = [];
+        for (;;) {
+          const query: ItemsQuery = provider.paginationMode === "CURSOR"
+            ? { cursorPaging: { limit: pageSize, ...(cursor ? { cursor } : {}) } }
+            : provider.paginationMode === "OFFSET" ? { paging: { limit: pageSize, offset } } : {};
+          const response = await queryItems(w.providerKey, query);
+          const page = itemsOf(response);
+          items.push(...page);
+
+          // Providers expose their paging state with the page. Follow every
+          // advertised page so an owner can select an item beyond the first 50.
+          // Stop on an empty raw page or a repeated cursor to avoid looping on
+          // malformed provider metadata.
+          const rawCount = response?.items?.length ?? 0;
+          const hasNext = response?.pagingMetadata?.hasNext;
+          if (provider.paginationMode === "CURSOR") {
+            const next = response?.pagingMetadata?.cursors?.next ?? "";
+            if (!next || hasNext === false || rawCount === 0 || seenCursors.has(next)) break;
+            seenCursors.add(next);
+            cursor = next;
+          } else if (provider.paginationMode === "OFFSET") {
+            if (hasNext !== true || rawCount === 0) break;
+            offset += pageSize;
+          } else {
+            break;
+          }
+        }
+        options = items.map((item, i) => {
+          const pictureUrl = isWixMediaHost(hostOf(item.imageUrl)) ? item.imageUrl : "";
+          return {
+            id: `o${i}`, value: item.id, title: item.title, subtitle: item.subtitle,
+            subtitleHidden: !item.subtitle, text: "", textHidden: true,
+            pictureUrl, pictureHidden: !pictureUrl, buttonLabel: "", buttonHidden: true,
+            listText: "", listHidden: true, selected: false, respondText: "",
+            actionUrl: "", actionScreenId: "", notSupportedText: "",
+          };
+        });
+      }
+    } catch (e) {
+      error = isWixAccountUnreachable(e) || String((e as Error)?.message ?? e).includes("absolute_urls_not_allowed")
+        ? widgetItemsUnavailableText() : widgetItemsFailedText();
+    }
+    const loaded = {
+      ...w, options, itemsLoading: false, itemsLoadingHidden: true,
+      itemsError: error, itemsErrorHidden: !error, itemsEmpty: options.length === 0,
+    };
+    return { ...s, widget: reselect(loaded, options) };
   };
 
+  /** The questionnaire's derived fields in THIS app's words. `viewOf` derives
+   *  them in the stock copy, having none of its own. */
+  const localized = (w: WidgetView): WidgetView =>
+    w.kind === "QUESTIONNAIRE"
+      ? questionnaireSynced(w, w.questionIndex, questionnaireCopy(), !w.answersTextHidden)
+      : w;
+
   const observed = (msgs: ConversationMessage[], prev?: WidgetView) => ({
     _srvUsers: countTurns(msgs, "USER"),
     _srvAssistants: countTurns(msgs, "ASSISTANT"),
@@ -2015,15 +2158,15 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // envelopes into live interactive cards. The transcript path already did
     // both; the widget path did neither.
     widget: carrySelection(
-      activeWidgetOf(
+      localized(activeWidgetOf(
         // A draft offers no controls: the agent has not finished asking, and
         // an answer tapped now would start a second turn on top of this one.
         // An empty newest row is NO_WIDGET — the placeholder rule.
-        msgs.map((m) => ({ role: m.role, content: stillWriting(m) ? "" : stripHidden(messageText(m)) })),
+        msgs.map((m) => ({ id: m.id, role: m.role, content: stillWriting(m) ? "" : stripHidden(messageText(m)) })),
         disclosedLabel,
         o.subtree,
         (url) => isWixMediaHost(hostOf(url)),
-      ),
+      )),
       prev,
     ),
   });
@@ -2082,7 +2225,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       seen = raw;
       const failed = takeToolFailure(convId);
       if (failed) {
-        return { ...s, status: "ready", _convId: convId, messages: server, input: "", _pending: "", _abortId: "", ...observed(raw, s.widget), ok: false, ...toolFailureSlots(failed) };
+        return withWidgetItems({ ...s, status: "ready", _convId: convId, messages: server, input: "", _pending: "", _abortId: "", ...observed(raw, s.widget), ok: false, ...toolFailureSlots(failed) });
       }
       // Not over while the agent is waiting on a client tool from us — and this
       // loop has no clock of its own, so re-reading meanwhile would spend its
@@ -2094,10 +2237,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // the last BUBBLE stalled this loop on exactly that reply, the same way it
       // stalled `tick`.
       if (toolReplied(convId, raw) ?? repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter) {
-        return { ...s, status: "ready", _convId: convId, messages: bubbles, prompts: [], input: "", statusText: "", error: "", _pending: "", ...observed(raw, s.widget), ok: false };
+        return withWidgetItems({ ...s, status: "ready", _convId: convId, messages: bubbles, prompts: [], input: "", statusText: "", error: "", _pending: "", ...observed(raw, s.widget), ok: false });
       }
     }
-    return { ...s, status: "ready", _convId: convId, messages: server, input: "", statusText: slowText(), _pending: "", ...observed(seen, s.widget), ok: false };
+    return withWidgetItems({ ...s, status: "ready", _convId: convId, messages: server, input: "", statusText: slowText(), _pending: "", ...observed(seen, s.widget), ok: false });
   }
 
   /** Send + wait, by whichever transport this consumer configured. */
@@ -2600,6 +2743,20 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
    *  selection and the payload — and a toggle that updated two of the three is
    *  the shape of bug that leaves a button enabled over an empty selection. */
   const reselect = (w: WidgetView, options: WidgetOptionRow[]): WidgetView => {
+    // A questionnaire's `options` are the question ON SCREEN's choices, so a
+    // selection is written back into that question and everything re-derived
+    // from the answers — the Next gate and the submit gate included.
+    if (w.kind === "QUESTIONNAIRE") {
+      const i = w.questionIndex;
+      const questions = w.questions.map((q, j) => {
+        if (j !== i) return q;
+        // A single-select takes ONE answer: choosing a choice replaces what
+        // was typed, as typing replaces the choice (`widgetAnswer`).
+        const picked = options.some((c) => c.selected);
+        return { ...q, choices: options, freeText: q.type === "single-select" && picked ? "" : q.freeText };
+      });
+      return questionnaireSynced({ ...w, questions }, i, questionnaireCopy(), true);
+    }
     const chosen = options.filter((o) => o.selected).length;
     const limitReached = w.maxSelected > 0 && chosen >= w.maxSelected;
     // Only says anything once the owner is actually against the limit. A line
@@ -2658,8 +2815,8 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
           // `copyNote: ""` — a resumed transcript ends in a reply, so the row is
           // shown at once; a note carried over would say "Copied" beside an
           // answer from a different conversation that nobody copied.
-          return leaving({ ...s, status: "ready", _convId: resumeId, _siteId: site, _pending: "", statusText: "", error: "", copyNote: "",
-            messages: resumed, ...observed(raw, s.widget), prompts: promptsFor(resumed, promptList()) });
+          return leaving(await withWidgetItems({ ...s, status: "ready", _convId: resumeId, _siteId: site, _pending: "", statusText: "", error: "", copyNote: "",
+            messages: resumed, ...observed(raw, s.widget), prompts: promptsFor(resumed, promptList()) }));
         } catch { /* expired or unreachable — fall through to a fresh one */ }
       }
       // Opening a screen runs `load` more than once — the bundle self-kicks at
@@ -2864,8 +3021,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // AFTER the transcript rebuild, so a widget that has just been retired
         // by a new answer is never polled for.
         const withJob = { ...next, widget: await withJobProgress(next.widget) };
+        const withItems = await withWidgetItems(withJob);
+        if (turnSeq !== seq || abortingEpochs.has(seq)) return undefined;
         // Slow the ladder the moment the turn is over; leave it alone otherwise.
-        return ended && wasFast ? cadence(withJob, o.poll.idleMs, o.poll.fastMs) : withJob;
+        return ended && wasFast ? cadence(withItems, o.poll.idleMs, o.poll.fastMs) : withItems;
       } catch {
         // A read that THREW is exactly as stale as one that resolved: if a turn
         // boundary moved on while it was in flight, returning `s` merges the
@@ -2909,28 +3068,49 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     },
 
     widgetAnswer: (s, arg) => {
-      const qid = (typeof arg === "string" ? arg : (arg?.id ?? "")).trim();
-      const answer = typeof arg === "string" ? "" : firstString(arg?.value, arg?.text);
-      if (!qid) return s;
-      const questions = s.widget.questions.map((q) =>
-        q.id === qid
-          ? { ...q, answer, answerHidden: !answer, missing: q.required && !answer }
-          : q);
-      if (questions === s.widget.questions) return s;
-      const incomplete = questions.some((q) => q.missing);
-      return {
-        ...s,
-        widget: {
-          ...s.widget,
-          questions,
-          answersIncomplete: incomplete,
-          // Only says anything while something is actually missing.
-          answersText: incomplete ? answersIncompleteText() : "",
-          answersTextHidden: !incomplete,
-          primaryDisabled: s.widget.submitting || incomplete,
-          primaryEnabled: !(s.widget.submitting || incomplete),
-        },
-      };
+      const w = s.widget;
+      if (w.kind !== "QUESTIONNAIRE") return s;
+      const qid = (typeof arg === "string" ? arg : firstString(arg?.id)).trim();
+      const i = w.questions.findIndex((q) => q.id === qid);
+      // Text for a question that offers no field to type it into is not an
+      // answer the owner gave; it cannot satisfy a required choice.
+      if (i < 0 || w.questions[i].freeHidden) return s;
+      // VERBATIM, not trimmed: this runs on every keystroke, and trimming here
+      // would eat the space between two words the moment it is typed. The
+      // answer is trimmed where it is READ (`questionnaireSynced`).
+      const text = typeof arg === "string" ? "" : firstStringRaw(arg?.value, arg?.text);
+      const questions = w.questions.map((q, j) => {
+        if (j !== i) return q;
+        // Typing into a single-select's "something else" IS the answer, so it
+        // takes the place of any choice — one question, one answer.
+        const replaces = q.type === "single-select" && !!text.trim();
+        return {
+          ...q,
+          freeText: text,
+          choices: replaces ? q.choices.map((c) => (c.selected ? { ...c, selected: false } : c)) : q.choices,
+        };
+      });
+      // Re-derived for the question the owner is LOOKING AT, whichever one the
+      // text arrived for — a late keystroke from the previous question must not
+      // flip the screen back to it.
+      return { ...s, widget: questionnaireSynced({ ...w, questions }, w.questionIndex, questionnaireCopy(), true) };
+    },
+
+    widgetStep: (s, arg) => {
+      const w = s.widget;
+      if (w.kind !== "QUESTIONNAIRE" || w.submitting) return s;
+      const step = typeof arg === "string" ? arg.trim() : firstString(arg?.step, arg?.value, arg?.id);
+      const current = w.questions[w.questionIndex];
+      if (!current) return s;
+      if (step === "back") {
+        if (w.questionIndex === 0) return s;
+        return { ...s, widget: questionnaireSynced(w, w.questionIndex - 1, questionnaireCopy(), true) };
+      }
+      if (step !== "next") return s;
+      // The same rule the greyed Next shows. Refused here as well, because a
+      // descriptor flag is a picture of the rule, not the rule.
+      if (current.missing || w.questionIndex >= w.questions.length - 1) return s;
+      return { ...s, widget: questionnaireSynced(w, w.questionIndex + 1, questionnaireCopy(), true) };
     },
 
     // --- Mentions -----------------------------------------------------------
@@ -3061,18 +3241,63 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // a send that had already failed.
       if (widgetSending) return s;
 
-      const option = w.options.find((o) => o.value === which);
-      const template = option
-        ? option.respondText
-        : which === "secondary" ? w.secondaryRespondText : w.primaryRespondText;
+      // A VISUAL_DISPLAY section's own button ("Edit" beside a row). Named by
+      // its own key, `section`, never by `value`: a section is not an option,
+      // and an option whose value happened to equal a row id must not be able
+      // to answer for it. The clone's positional form can only say `value`, so
+      // a row id there is tried only once no option has claimed it.
+      const sectionId = typeof arg === "object" ? firstString(arg?.section) : "";
+      const option = sectionId ? undefined : w.options.find((o) => o.value === which);
+      const section = sectionId
+        ? w.rows.find((r) => r.id === sectionId)
+        : (option ? undefined : w.rows.find((r) => r.id === which));
+      if (sectionId && !section) return s;
+
+      // An option with a supported URL goes there even when the payload also
+      // includes a respondText fallback. The view removes an unsupported URL
+      // and its fallback before this action can run, so it cannot turn into a
+      // different response. Screen-only options still use respondText when
+      // present; otherwise show why the Wix-native screen cannot open here.
+      if (option?.actionUrl) return openWidgetUrl(s, option.actionUrl);
+
+      // An option whose button goes to a screen of the native Wix app — the
+      // catalogue's "Open store settings". This app has none of those screens,
+      // so a screen-only option must explain the limitation rather than leave
+      // a button that does nothing.
+      if (option && !option.respondText) {
+        if (option.actionScreenId) {
+          // A screen of the native Wix app. This app has none of them, so the
+          // honest thing is to say so — the payload's own words when it sent
+          // some, ours otherwise — rather than leave the tap unanswered.
+          const notice = option.notSupportedText || notSupportedText();
+          return { ...s, widget: { ...w, notice, noticeHidden: !notice } };
+        }
+        return s;
+      }
+
+      const questionnaire = w.kind === "QUESTIONNAIRE" && !option && !section && which !== "secondary";
+      // The submit is gated on the required answers; refused here too, since a
+      // greyed button is only a picture of the rule.
+      if (questionnaire && (w.answersIncomplete || w.questionIndex < w.questions.length - 1)) return s;
+
+      const template = section
+        ? section.respondText
+        : option
+          ? option.respondText
+          : which === "secondary" ? w.secondaryRespondText : w.primaryRespondText;
       if (!template) return s;
 
       // What the owner actually chose. An option's own button answers with
       // ITSELF even when nothing is ticked — tapping "Select" on a row IS the
-      // selection — while a footer button speaks for the accumulated set.
-      const selected = option && !option.selected
-        ? [option.title || option.value]
-        : w.options.filter((o) => o.selected).map((o) => o.title || o.value);
+      // selection — while a footer button speaks for the accumulated set. A
+      // questionnaire speaks for EVERY question, not the one on screen.
+      const selected = section
+        ? []
+        : questionnaire
+          ? [questionnaireAnswers(w)].filter(Boolean)
+          : option && !option.selected
+            ? [option.title || option.value]
+            : w.options.filter((o) => o.selected).map((o) => o.title || o.value);
       const content = substituteSelection(template, selected).trim();
       if (!content) return s;
       if (duplicate(s, content)) return s;
@@ -3468,6 +3693,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     widgetPick: (s, arg) => gated(impl.widgetPick(s, arg)),
     widgetQuery: (s, arg) => gated(impl.widgetQuery(s, arg)),
     widgetAnswer: (s, arg) => gated(impl.widgetAnswer(s, arg)),
+    widgetStep: (s, arg) => gated(impl.widgetStep(s, arg)),
     widgetRespond: (s, arg) => impl.widgetRespond(s, arg).then(gated),
     widgetPrimary: (s) => impl.widgetPrimary(s).then(gated),
     widgetSecondary: (s) => impl.widgetSecondary(s).then(gated),

package/templates/portfolio-creative-owner/tier5-src/_shared/aria-widget-model.ts

@@ -107,6 +107,8 @@ export interface WidgetButton {
    *  and this
    *  model must not grow a second URL check. */
   externalUrl: string;
+  /** `mobileAction.screen.id` — a destination the widget footer cannot open. */
+  actionScreenId: string;
 }
 
 /** The normalized widget. One shape for all fifteen arms.
@@ -275,6 +277,7 @@ export function buttonAt(o: Record<string, unknown> | null, key: string): Widget
     // Two spellings for one concept, and both are live in the catalogue:
     // PREMIUM_UPSELL sends `externalLink`, CHART sends `link`.
     externalUrl: stringAt(action, "externalLink") || stringAt(action, "link"),
+    actionScreenId: stringAt(objectAt(action?.screen), "id"),
   };
 }