@wix/himalaya-cli 0.1250.0 → 0.1252.0

package/templates/beauty-salon-owner/tier5-src/_shared/aria-widget-view.ts

@@ -12,8 +12,8 @@
 // every collapsible element carries its own `*Hidden` boolean — the same shape
 // the transcript bubbles already use for their three link slots.
 
-import type { NormalizedWidget, WidgetKind } from "./aria-widget-model.js";
-import { isWebUrl, stripMarkdown } from "./aria-widget-model.js";
+import type { NormalizedWidget, WidgetKind, WidgetOption } from "./aria-widget-model.js";
+import { SELECTED_TOKEN, VALUES_TOKEN, isWebUrl, stripMarkdown } from "./aria-widget-model.js";
 import { composeGenericCard } from "./aria-generic-widget.js";
 import { normalizeWidget } from "./aria-widget-kinds.js";
 import { scanEnvelopes, widgetsOfParts } from "./aria-widgets.js";
@@ -22,6 +22,7 @@ import { scanEnvelopes, widgetsOfParts } from "./aria-widgets.js";
  *  rather than imported from `aria-chat.ts` so this module has no dependency on
  *  it at all — see `Disclose` below for why that matters. */
 export interface WidgetSourceMessage {
+  id?: string;
   role?: string;
   content?: unknown;
 }
@@ -60,6 +61,12 @@ export interface WidgetRow {
   /** `true` when `subtitle` is empty, so the row collapses its second line
    *  instead of leaving a gap. `$item.` cannot express "hide when empty". */
   subtitleHidden: boolean;
+  /** The section's own `textButton` — VISUAL_DISPLAY's "Edit" beside a row.
+   *  It sends `respondText`, so a button with no text to send is hidden: a
+   *  label alone is a control that does nothing. */
+  buttonLabel: string;
+  buttonHidden: boolean;
+  respondText: string;
 }
 
 /** One selectable option, flattened for binding.
@@ -89,6 +96,15 @@ export interface WidgetOptionRow {
   /** This option's own button `respondText`, before substitution. Carried on
    *  the row because the row is what a tap identifies. */
   respondText: string;
+  /** The option button's own destination (`mobileAction.link` /
+   *  `externalLink`), web schemes only. Anything else is dropped HERE, so the
+   *  button is never painted for a navigation the opener would refuse. */
+  actionUrl: string;
+  /** `mobileAction.screen.id` — a screen of the native Wix app. This app has
+   *  no such screen, so a tap says so (`notSupportedText`) instead of doing
+   *  nothing. */
+  actionScreenId: string;
+  notSupportedText: string;
 }
 
 /** One slice of a CHART. `value` is a RAW magnitude, never a percentage: the
@@ -111,6 +127,9 @@ export interface WidgetStep {
 /** The active widget, as the screen reads it. */
 export interface WidgetView {
   kind: WidgetCase;
+  /** Transcript row that owns this widget; prevents state carrying into a later
+   *  identical-looking ask. */
+  sourceMessageId?: string;
   /** `true` when there is nothing to show. The whole region is hidden on this
    *  rather than on `kind === "NONE"`, because a descriptor cannot compare —
    *  `hiddenWhen` binds a boolean and nothing else. It is what keeps the region
@@ -166,6 +185,19 @@ export interface WidgetView {
   primaryEnabled: boolean;
   /** A send started from a widget button is in flight. */
   submitting: boolean;
+  /** A line explaining a tap that could not go anywhere — an option whose
+   *  destination is a screen this app does not have. Empty otherwise. */
+  notice: string;
+  noticeHidden: boolean;
+  /** MULTI_SELECT's `optionLayout: "thumbnail"`: the options as a grid of
+   *  picture tiles rather than a list of rows. Two flags, one per form, because
+   *  a descriptor cannot compare the layout string. */
+  optionsGridHidden: boolean;
+  optionsListHidden: boolean;
+  /** MULTI_SELECT's `footerButtonsAsColumn`: the footer stacked rather than in
+   *  a row. Same two-flag shape. */
+  footerRowHidden: boolean;
+  footerColumnHidden: boolean;
 
   // --- CHART ---------------------------------------------------------------
   /** `$service:`-bound, and it has to be: `DonutChart.slices_path` and
@@ -241,8 +273,31 @@ export interface WidgetView {
   selectionType: string;
 
   // --- QUESTIONNAIRE -------------------------------------------------------
+  /** Every question, with its answer so far. NOT bound by the descriptor: a
+   *  question's choices are a list inside a list, and `$item.` cannot carry an
+   *  array. So the screen shows ONE question at a time — `questionHead`, the
+   *  current question's choices in `options`, and `questionFree`. */
   questions: WidgetQuestion[];
   questionsEmpty: boolean;
+  /** Which question is on screen. */
+  questionIndex: number;
+  /** The current question as a ONE-row list (empty when there is none), so its
+   *  labels are `$item.`-bound like every other row on this screen. */
+  questionHead: WidgetQuestionHead[];
+  /** The current question's free-text field as a one-row list, or empty when
+   *  the question offers none. */
+  questionFree: WidgetQuestionFree[];
+  /** Which control the current question's choices use. Two flags, because a
+   *  descriptor cannot compare `type`. */
+  questionRadioHidden: boolean;
+  questionCheckHidden: boolean;
+  /** Back / Next. Next is hidden on the last question, where the primary
+   *  (submit) takes its place, and held — the greyed twin — on a required
+   *  question with no answer yet. */
+  questionBackHidden: boolean;
+  questionNextHidden: boolean;
+  questionNextDisabled: boolean;
+  questionNextEnabled: boolean;
   /** `true` while any `required` question is unanswered. The submit is gated
    *  on it — there is no cross-field validation in `Validation`, so "every
    *  required question has an answer" has to be worked out here. */
@@ -272,8 +327,7 @@ export interface WidgetView {
   treeJson: string;
 }
 
-/** One question of a QUESTIONNAIRE, flattened. `$item.`-templated, so every
- *  field is present and scalar. */
+/** One question of a QUESTIONNAIRE, and the owner's answer to it so far. */
 export interface WidgetQuestion {
   id: string;
   title: string;
@@ -290,8 +344,166 @@ export interface WidgetQuestion {
   /** The free-text escape hatch, per question. */
   freePlaceholder: string;
   freeHidden: boolean;
+  /** This question's choices, `selected` as the owner left them. */
+  choices: WidgetOptionRow[];
+  /** What the owner typed into the free-text field. */
+  freeText: string;
 }
 
+/** The on-screen question's labels. All-scalar: `$item.`-bound. */
+export interface WidgetQuestionHead {
+  id: string;
+  /** The title, with a `*` when an answer is required. */
+  title: string;
+  subtitle: string;
+  subtitleHidden: boolean;
+  /** "2 of 3". Empty — and hidden — for a one-question form. */
+  progress: string;
+  progressHidden: boolean;
+}
+
+/** The on-screen question's free-text field. All-scalar: `$item.`-bound. */
+export interface WidgetQuestionFree {
+  /** The question id — what `widgetAnswer` is told the text belongs to. */
+  id: string;
+  placeholder: string;
+  value: string;
+}
+
+/** The questionnaire's words. Passed in, like `Disclose`, so this module stays
+ *  free of any copy source and the host can localize them. */
+export interface QuestionnaireCopy {
+  progress(current: number, total: number): string;
+  /** Shown while a required answer is missing, once the owner has started. */
+  incomplete: string;
+  /** The submit's label when the payload's primary button has none. */
+  submit: string;
+}
+
+export const DEFAULT_QUESTIONNAIRE_COPY: QuestionnaireCopy = {
+  progress: (current, total) => `${current} of ${total}`,
+  incomplete: "Answer the required questions to continue.",
+  submit: "Submit",
+};
+
+/** A question's answer as the owner would say it: the chosen choices' titles,
+ *  then anything typed. Empty when unanswered. */
+function answerOf(q: WidgetQuestion): string {
+  const parts = q.choices.filter((c) => c.selected).map((c) => c.title || c.value);
+  const typed = q.freeText.trim();
+  if (typed) parts.push(typed);
+  return parts.join(", ");
+}
+
+/** Re-derive everything a questionnaire shows from its answers and the
+ *  question on screen.
+ *
+ *  ONE function, called after every change — arrival, a tap, typing, Back,
+ *  Next, a poll — for the reason `reselect` is one function: the head row,
+ *  the choices, the Next gate and the submit gate are all pure functions of
+ *  the same two inputs, and a reducer that updated three of the four is how a
+ *  submit ends up enabled over a missing answer.
+ *
+ *  `touched` decides whether the incomplete line may show. On arrival nothing
+ *  is answered yet, and a form that opens by scolding reads as broken. */
+export function questionnaireSynced(
+  w: WidgetView,
+  index: number,
+  copy: QuestionnaireCopy,
+  touched: boolean,
+): WidgetView {
+  const questions = w.questions.map((q) => {
+    const answer = answerOf(q);
+    return { ...q, answer, answerHidden: !answer, missing: q.required && !answer };
+  });
+  const total = questions.length;
+  const i = total ? Math.max(0, Math.min(index, total - 1)) : 0;
+  const q = questions[i];
+  const isLast = i >= total - 1;
+  const incomplete = questions.some((x) => x.missing);
+  const multi = q?.type === "multi-select";
+  const hasChoices = !!q && q.choices.length > 0;
+  const emptySelectionSubmit = !!w.primaryRespondText
+    && (w.primaryRespondText.includes(SELECTED_TOKEN) || w.primaryRespondText.includes(VALUES_TOKEN))
+    && !questions.some((question) => answerOf(question));
+  const blocked = w.submitting || incomplete || emptySelectionSubmit;
+  // A primary with a destination is navigation, not questionnaire submit.
+  // Keep it available while required answers are incomplete; the submit action
+  // remains gated in the worker as well as in the descriptor.
+  const primaryDisabled = !!w.primaryUrl ? w.submitting : blocked;
+  const hasSubmit = !!(w.primaryRespondText || w.primaryUrl);
+  const primaryLabel = hasSubmit ? (w.primaryLabel || copy.submit) : "";
+  const answersText = touched && isLast && incomplete ? copy.incomplete : "";
+  return {
+    ...w,
+    questions,
+    questionIndex: i,
+    options: q ? q.choices : [],
+    questionHead: q
+      ? [{
+          id: q.id,
+          title: q.required ? `${q.title} *` : q.title,
+          subtitle: q.subtitle, subtitleHidden: !q.subtitle,
+          progress: total > 1 ? copy.progress(i + 1, total) : "",
+          progressHidden: total <= 1,
+        }]
+      : [],
+    questionFree: q && !q.freeHidden
+      ? [{ id: q.id, placeholder: q.freePlaceholder, value: q.freeText }]
+      : [],
+    questionRadioHidden: !hasChoices || multi,
+    questionCheckHidden: !hasChoices || !multi,
+    questionBackHidden: i === 0,
+    questionNextHidden: !q || isLast,
+    questionNextDisabled: !!q?.missing,
+    questionNextEnabled: !q?.missing,
+    answersIncomplete: incomplete,
+    answersText, answersTextHidden: !answersText,
+    // The submit only exists on the last question. Before it, Next stands
+    // where it would be — two primaries side by side ask the owner to guess.
+    primaryLabel,
+    primaryHidden: !q || !isLast || !hasSubmit,
+    primaryDisabled,
+    primaryEnabled: !primaryDisabled,
+  };
+}
+
+/** The answers, as the one message a questionnaire sends. Numbered when there
+ *  is more than one question, so the assistant can tell which answer is whose;
+ *  an unanswered optional question is left out rather than sent blank. */
+export function questionnaireAnswers(w: WidgetView): string {
+  const numbered = w.questions.length > 1;
+  return w.questions
+    .map((q, i) => ({ i, a: answerOf(q) }))
+    .filter((x) => x.a)
+    .map((x) => (numbered ? `${x.i + 1}. ${x.a}` : x.a))
+    .join("\n");
+}
+
+/** Is `b` the same questionnaire as `a` — so an owner's answers to `a` still
+ *  belong to it? Compared on what the owner answered AGAINST: the questions and
+ *  their choices. */
+export function sameQuestionnaire(a: WidgetView, b: WidgetView): boolean {
+  if (a.kind !== "QUESTIONNAIRE" || b.kind !== "QUESTIONNAIRE") return false;
+  if (a.questions.length !== b.questions.length) return false;
+  return a.questions.every((q, i) => {
+    const o = b.questions[i];
+    return q.title === o.title && q.type === o.type && q.choices.length === o.choices.length
+      && q.choices.every((c, j) => c.value === o.choices[j].value);
+  });
+}
+
+/** The one-question-at-a-time fields for anything that is not a questionnaire:
+ *  no question, and every control collapsed. */
+const NO_QUESTION = {
+  questionIndex: 0,
+  questionHead: [] as WidgetQuestionHead[],
+  questionFree: [] as WidgetQuestionFree[],
+  questionRadioHidden: true, questionCheckHidden: true,
+  questionBackHidden: true, questionNextHidden: true,
+  questionNextDisabled: false, questionNextEnabled: true,
+};
+
 /** Nothing to show. The region binds this and collapses. */
 export const NO_WIDGET: WidgetView = {
   kind: "NONE",
@@ -307,6 +519,9 @@ export const NO_WIDGET: WidgetView = {
   options: [], maxSelected: 0, limitReached: false, requiresSelection: false,
   limitText: "", limitTextHidden: true,
   primaryDisabled: false, primaryEnabled: true, submitting: false,
+  notice: "", noticeHidden: true,
+  optionsGridHidden: true, optionsListHidden: false,
+  footerRowHidden: false, footerColumnHidden: true,
   slices: [], values: [], chartIsPie: false, chartIsSeries: false, chartKind: "",
   chartPieHidden: true, chartSeriesHidden: true, chartEmptyHidden: true,
   asyncSpinnerHidden: true, itemsLoadingHidden: true,
@@ -317,6 +532,7 @@ export const NO_WIDGET: WidgetView = {
   query: "", suggestions: [], suggestionsEmpty: true, noMatches: false, selectionType: "",
   questions: [], questionsEmpty: true, answersIncomplete: false,
   answersText: "", answersTextHidden: true,
+  ...NO_QUESTION,
   providerKey: "", itemsLoading: false, itemsError: "", itemsErrorHidden: true, itemsEmpty: true,
   treeJson: "",
 };
@@ -359,7 +575,7 @@ function optionRow(
   o: {
     value: string; title: string; subtitle: string; text: string;
     pictureUrl: string; buttonLabel: string; actionUrl: string; listText: string;
-    respondText: string;
+    respondText: string; actionScreenId?: string; notSupportedText?: string;
   },
   i: number,
   selected: boolean,
@@ -388,7 +604,18 @@ function optionRow(
   // "(unknown site)" to a button that goes nowhere. That reads as a phishing
   // warning on the ordinary path and devalues the annotation on the path that
   // needs it.
-  const buttonLabel = discloseButton(disclose, o.buttonLabel, o.actionUrl);
+  //
+  // Web schemes only, decided HERE and not just at the opener: the button is
+  // painted for its destination, so a `tel:` or custom-scheme url the opener
+  // refuses would otherwise put up a live-looking control that does nothing.
+  const unsupportedUrl = !!o.actionUrl && !isWebUrl(o.actionUrl);
+  const actionUrl = o.actionUrl && isWebUrl(o.actionUrl) ? o.actionUrl.trim() : "";
+  const actionScreenId = o.actionScreenId ?? "";
+  const buttonLabel = discloseButton(disclose, o.buttonLabel, actionUrl);
+  // A URL destination wins over the fallback text. If this host cannot open
+  // that URL, hide the button rather than sending a different action.
+  const respondText = unsupportedUrl ? "" : o.respondText
+    || (genericFallback ? (o.title || o.text || o.subtitle || o.value) : "");
 
   // An option's two display lines.
   //
@@ -411,11 +638,15 @@ function optionRow(
     subtitle: rowSubtitle, subtitleHidden: !rowSubtitle,
     text: o.text, textHidden: !o.text,
     pictureUrl, pictureHidden: !pictureUrl,
-    buttonLabel, buttonHidden: !buttonLabel,
+    // A label is not enough: the button has to be able to DO something — say
+    // its text, go to its url, or explain why its screen is not here.
+    buttonLabel, buttonHidden: !(buttonLabel && (respondText || actionUrl || actionScreenId)),
     listText: o.listText, listHidden: !o.listText,
     selected,
-    respondText: o.respondText
-      || (genericFallback ? (o.title || o.text || o.subtitle || o.value) : ""),
+    respondText,
+    actionUrl,
+    actionScreenId,
+    notSupportedText: o.notSupportedText ?? "",
   };
 }
 
@@ -486,6 +717,10 @@ export function viewOf(
   const sections = Array.isArray(extra.sections) ? (extra.sections as Record<string, unknown>[]) : [];
   const rows: WidgetRow[] = sections.map((sec, i) => {
     const subtitle = stripMarkdown(typeof sec.subtitle === "string" ? sec.subtitle : "");
+    // Painted, so flattened like every other button label (`discloseButton`).
+    // `respondText` is SENT, not painted, so it goes back verbatim.
+    const buttonLabel = stripMarkdown(typeof sec.buttonLabel === "string" ? sec.buttonLabel : "");
+    const respondText = typeof sec.respondText === "string" ? sec.respondText : "";
     return {
       // A stable id per row. Index-based on purpose: a section has no id of its
       // own, and the list is rebuilt wholesale on every tick, so there is
@@ -494,13 +729,32 @@ export function viewOf(
       title: stripMarkdown(typeof sec.title === "string" ? sec.title : ""),
       subtitle,
       subtitleHidden: !subtitle,
+      // The section's `textButton`. It can only SEND, so without a text to
+      // send it would be a label that does nothing when tapped.
+      buttonLabel,
+      buttonHidden: !(buttonLabel && respondText),
+      respondText,
     };
   });
 
   const maxSelected = typeof extra.maxSelected === "number" ? extra.maxSelected : 0;
+  const thumbnail = w.kind === "MULTI_SELECT" && extra.optionLayout === "thumbnail";
+  const stacked = w.kind === "MULTI_SELECT" && extra.footerButtonsAsColumn === true;
   // `isPreselected` seeds the selection, so the row's `selected` starts true
   // for exactly the options the service marked.
-  const options: WidgetOptionRow[] = w.options.map((o, i) => optionRow(o, i, o.preselected, disclose, allowPicture, w.kind === "UNKNOWN"));
+  const mappedOptions: WidgetOptionRow[] = w.options.map((o, i) => optionRow(o, i, o.preselected, disclose, allowPicture, w.kind === "UNKNOWN"));
+  // SINGLE_SELECT's whole row responds to a tap, even when its trailing button
+  // is hidden. A phone/custom-scheme-only destination has no action this host
+  // can perform; keep rows with a text response or explainable screen action.
+  const options = w.kind === "SINGLE_SELECT"
+    ? mappedOptions.filter((row, i) => {
+        const rawUrl = w.options[i]?.actionUrl ?? "";
+        // A normal single-select row has no actionUrl and is selectable by
+        // definition. A declared unsupported URL wins over any fallback text
+        // or screen destination, so that row must be removed.
+        return !rawUrl || isWebUrl(rawUrl);
+      })
+    : mappedOptions;
 
   // CHART. `pieSlices` is the only shape the catalogue sends, but `chartType`
   // decides the component: a pie is a `DonutChart` at zero thickness, anything
@@ -546,16 +800,35 @@ export function viewOf(
     const sub = typeof q.subtitle === "string" ? q.subtitle : "";
     const free = typeof q.freeFormatPlaceholder === "string" ? q.freeFormatPlaceholder : "";
     const required = q.required === true;
+    const type = typeof q.type === "string" ? q.type : "";
+    // The choices. Dropping these is what made the catalogue's required
+    // single-select unanswerable: it has no free-text field, so a form that
+    // drew only that field had nothing the owner could give it.
+    const raw = Array.isArray(q.options) ? (q.options as WidgetOption[]) : [];
+    // A single-select starts with at most ONE preselected choice, whatever the
+    // payload marked — a radio group showing two ticks is a state the control
+    // cannot otherwise reach.
+    let seeded = false;
+    const choices = raw.map((o, j) => {
+      const pre = !!o.preselected && (type !== "single-select" || !seeded);
+      if (pre) seeded = true;
+      return optionRow(o, j, pre, disclose, allowPicture);
+    });
+    // A question with no choices and no free-text option of its own can still
+    // be answered — text is the only thing it can take — so it gets the field.
+    const freeShown = !!free || choices.length === 0;
     return {
       id: `q${i}`,
       title: typeof q.title === "string" ? q.title : "",
       subtitle: sub, subtitleHidden: !sub,
-      type: typeof q.type === "string" ? q.type : "",
+      type,
       required,
-      // Nothing is answered on arrival, so a required question starts missing.
+      // Derived by `questionnaireSynced`, which runs before this is returned.
       missing: required,
       answer: "", answerHidden: true,
-      freePlaceholder: free, freeHidden: !free,
+      freePlaceholder: free, freeHidden: !freeShown,
+      choices,
+      freeText: "",
     };
   });
 
@@ -581,10 +854,37 @@ export function viewOf(
   // The synthesized template is the label itself, which is what `<SELECTED>`
   // substitution produces for the known kinds anyway.
   const generic = w.kind === "UNKNOWN";
-  const primaryRespondText = (w.primary?.respondText ?? "")
-    || (generic ? (w.primary?.label ?? "") : "");
-  const secondaryRespondText = (w.secondary?.respondText ?? "")
+  // A QUESTIONNAIRE's submit is the one KNOWN kind that can synthesize its
+  // response template: the catalogue sends `{label: "Send answers"}` and
+  // nothing else, and what it should say is fully determined — the answers.
+  // Only do that when the button declares no destination. If it declares a
+  // phone URL or a native Wix screen this host cannot open, hide the control
+  // instead of turning the destination into an answer submit.
+  const primaryUnsupportedUrl = !!(w.primary?.externalUrl && !primaryUrl);
+  const secondaryUnsupportedUrl = !!(w.secondary?.externalUrl && !secondaryUrl);
+  const primaryRespondFallback = w.primary?.respondText ?? "";
+  const secondaryRespondFallback = w.secondary?.respondText ?? "";
+  const primaryFallbackText = (w.primary?.respondText ?? "")
+    || (generic ? (w.primary?.label ?? "") : "")
+    || (w.kind === "QUESTIONNAIRE" && w.primary
+      && !w.primary.externalUrl && !w.primary.actionScreenId ? SELECTED_TOKEN : "");
+  const secondaryFallbackText = (w.secondary?.respondText ?? "")
     || (generic ? (w.secondary?.label ?? "") : "");
+  // A supported URL wins; an unsupported URL is suppressed so a phone/custom
+  // destination cannot turn into an unrelated response. A native Wix screen
+  // can use an explicit response as its fallback, but a questionnaire's
+  // primary is its answer submit, so never turn that screen destination into
+  // a submit. Do not synthesize a generic label as a screen fallback.
+  const primaryUnsupportedScreen = !!w.primary?.actionScreenId;
+  const secondaryUnsupportedScreen = !!w.secondary?.actionScreenId;
+  const primaryRespondText = primaryUnsupportedUrl
+    || (primaryUnsupportedScreen && (!primaryRespondFallback || w.kind === "QUESTIONNAIRE"))
+    ? ""
+    : primaryFallbackText;
+  const secondaryRespondText = secondaryUnsupportedUrl
+    || (secondaryUnsupportedScreen && !secondaryRespondFallback)
+    ? ""
+    : secondaryFallbackText;
   const primaryLabel = w.primary ? discloseButton(disclose, w.primary.label, primaryUrl) : "";
   const secondaryLabel = w.secondary ? discloseButton(disclose, w.secondary.label, secondaryUrl) : "";
   // Whether each footer button is actually SHOWN — a label to read AND
@@ -627,7 +927,7 @@ export function viewOf(
     || sections.length || slices.length || steps.length || questions.length
     || asyncMessage || treeJson);
 
-  return {
+  const view: WidgetView = {
     kind: w.kind,
     hidden: !renderable,
     options,
@@ -672,6 +972,7 @@ export function viewOf(
     questionsEmpty: w.kind === "QUESTIONNAIRE" && questions.length === 0,
     answersIncomplete: questions.some((q) => q.missing),
     answersText: "", answersTextHidden: true,
+    ...NO_QUESTION,
     providerKey,
     // An ITEMS_SELECTION arrives with NO rows — they come from the provider —
     // so it starts loading rather than starting empty.
@@ -686,6 +987,11 @@ export function viewOf(
       Object.entries(msgs).filter((kv): kv is [string, string] => typeof kv[1] === "string"),
     ),
     submitting: false,
+    notice: "", noticeHidden: true,
+    // Layout hints, honoured only where the catalogue sends them — MULTI_SELECT.
+    // Everything else keeps the one form its case draws.
+    optionsGridHidden: !thumbnail, optionsListHidden: thumbnail,
+    footerRowHidden: stacked, footerColumnHidden: !stacked,
     text: prose, textHidden: !prose,
     title, titleHidden: !title,
     bottomText: bottom, bottomTextHidden: !bottom,
@@ -712,6 +1018,12 @@ export function viewOf(
     secondaryRespondText,
     rows,
   };
+  // A questionnaire is shown one question at a time; its on-screen fields are
+  // derived, never stored, so they start from the same function every later
+  // change goes through. The worker re-derives with its own copy.
+  return w.kind === "QUESTIONNAIRE"
+    ? questionnaireSynced(view, 0, DEFAULT_QUESTIONNAIRE_COPY, false)
+    : view;
 }
 
 /** The widget the screen should be showing, read off the server transcript.
@@ -753,5 +1065,8 @@ export function activeWidgetOf(
   if (!found.length) return NO_WIDGET;
   // A turn with several envelopes shows the LAST, matching "one at a time"
   // and the reading order — the final ask is the live one.
-  return viewOf(normalizeWidget(found[found.length - 1]), disclose, subtree, allowPicture);
+  return {
+    ...viewOf(normalizeWidget(found[found.length - 1]), disclose, subtree, allowPicture),
+    sourceMessageId: m.id,
+  };
 }

package/templates/beauty-salon-owner/tier5-src/himi-owner-lite-aria/index.ts

@@ -203,6 +203,8 @@ const core = createAriaChat({
     // English. Says no "sign in": the owner already is, and the missing piece is
     // the app's binding, so there is no action for them to take.
     unavailable: () => copyParam("ownerAria.unavailable", "Aria can't reach your Wix account from here."),
+    questionnaireSubmit: () => copyParam("ownerAria.questionnaire.submit", "Submit"),
+    notSupported: () => copyParam("ownerAria.notSupported", "That isn't available in this app yet."),
     dictationEmpty: () => copyParam("ownerAria.dictationEmpty", "Didn't catch that. Check microphone access and try again."),
     dictationFailed: () => copyParam("ownerAria.dictationFailed", "Dictation isn't available right now."),
     // The mention picker. Through copyParam for the same reason as the rest.
@@ -217,6 +219,8 @@ const core = createAriaChat({
     // sentence around it is localized.
     mentionItemsFailed: (category: string) =>
       copyTemplate("ownerAria.mention.itemsFailed", "Couldn't load {category}.", { category }),
+    widgetItemsFailed: () => copyParam("ownerAria.widget.itemsFailed", "Couldn't load these items."),
+    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 }),
@@ -310,6 +314,7 @@ const svc = defineService<AriaChatState, {
   widgetPick: (s: AriaChatState, arg?: AriaActionArg) => AriaChatState;
   widgetQuery: (s: AriaChatState, arg?: AriaActionArg) => AriaChatState;
   widgetAnswer: (s: AriaChatState, arg?: AriaActionArg) => AriaChatState;
+  widgetStep: (s: AriaChatState, arg?: AriaActionArg) => AriaChatState;
   dictate: (s: AriaChatState) => AriaChatState;
   finishDictation: (s: AriaChatState) => AriaChatState;
   // `undefined` for a result whose session is no longer the live one — see the core.
@@ -361,6 +366,8 @@ const svc = defineService<AriaChatState, {
     widgetPick: core.widgetPick,
     widgetQuery: core.widgetQuery,
     widgetAnswer: core.widgetAnswer,
+    // A questionnaire's Back / Next — one question on screen at a time.
+    widgetStep: core.widgetStep,
     // Composer dictation: the mic, the listening row's Done, and the result
     // re-entering from `dictation.deliver` above. Exported for the same reason
     // as the widget actions — an action the entry does not name is a control