@wix/himalaya-cli 0.1039.0 → 0.1041.0

package/templates/retail-store-owner/tier5-src/_shared/aria-chat.ts

@@ -230,6 +230,15 @@ export interface AriaChatState {
    *  Stop that cannot stop anything is worse than no Stop, because the owner
    *  taps it, the answer arrives anyway, and the control is what they blame. */
   stopHidden: boolean;
+  /** The microphone is open for composer dictation. Set by `dictate`, cleared by
+   *  `finishDictation` and by the result landing. */
+  listening: boolean;
+  /** Gates for the composer's mic control and its "Listening…" row, in the
+   *  `hiddenPath` polarity. Derived in `gated`, like `stopHidden`: the mic is
+   *  collapsed for a consumer with no `dictation` configured and while it is
+   *  already listening; the listening row is collapsed whenever it is not. */
+  micHidden: boolean;
+  listeningHidden: boolean;
   /** Intentionally never true: a `form` submit that returns `ok` makes the host
    *  POP the screen. A chat composer must stay put, so the whole surface leaves
    *  this false and the bound message list simply re-renders. */
@@ -317,6 +326,13 @@ export interface AriaChatLabels {
    *  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. */
   unavailable?: Resolvable<string>;
+  /** Neutral line when dictation ended with nothing to insert. The recognizer
+   *  reports silence, a denied microphone and a missing engine the SAME way
+   *  (`cancelled`), so this cannot say which — it names both likely causes. */
+  dictationEmpty?: Resolvable<string>;
+  /** Error line when the host could not start dictation at all (the speech
+   *  capability is not registered, or refused the call). */
+  dictationFailed?: Resolvable<string>;
   /** The mention picker's copy. See `MentionLabels`. */
   mentionTitle?: Resolvable<string>;
   mentionNoProviders?: Resolvable<string>;
@@ -349,6 +365,41 @@ export interface AriaChatLabels {
   toolFailed?: Resolvable<string>;
 }
 
+/** One dictation outcome, handed back to the service by `AriaDictationOptions.deliver`.
+ *  `session` names the `dictate` tap it answers, so a result for a session that has
+ *  since been replaced is dropped instead of landing in the composer. */
+export interface AriaDictationResult {
+  session: number;
+  transcript?: string;
+  cancelled?: boolean;
+  /** The host refused or threw — as opposed to hearing nothing. */
+  failed?: boolean;
+}
+
+/** Composer dictation, over whatever speech binding the consumer has.
+ *
+ *  `listen` is NOT awaited by the action that starts it: an action's state only
+ *  paints when it returns, so awaiting a whole utterance would leave the mic tap
+ *  looking dead until the owner stopped talking. `dictate` returns "Listening…"
+ *  at once, and the result re-enters as a FRESH dispatch through `deliver` —
+ *  which is the bundle's own `svc.dictated`, since only the bundle holds `svc`. */
+export interface AriaDictationOptions {
+  /** Record one utterance and resolve with what was heard. Must REJECT when the
+   *  host cannot dictate at all, so that is told apart from hearing nothing. */
+  listen(): Promise<{ transcript: string; cancelled: boolean }>;
+  /** Close the microphone. On iOS this also resolves `listen` with what had been
+   *  heard so far, which is what makes "Done" keep the owner's words. */
+  stop(): Promise<void>;
+  /** Re-enter the service with the outcome — `(r) => { void svc.dictated(r); }`. */
+  deliver(result: AriaDictationResult): void;
+  /** Can this host recognize speech at all? Asked once, on the first `load`.
+   *  `false` (or a rejection) collapses the mic: a control that can only ever
+   *  answer "Didn't catch that" — a browser with no SpeechRecognition, a macOS
+   *  build whose recognizer is a stub — sends the owner to fix a microphone
+   *  permission that is not the problem. Omitted ⇒ assumed available. */
+  available?(): Promise<boolean>;
+}
+
 /** What the composer needs from the device to attach a photo. Supplied by the
  *  app's adapter, because both are capabilities the SCREEN has to declare — the
  *  shared core imports neither, so a consumer without attachments (the clone)
@@ -441,6 +492,9 @@ export interface AriaChatOptions {
    *  authoritative and account-scoped by the signed instance; losing the offline
    *  fallback is a far smaller cost than that. */
   localHistory?: boolean;
+  /** Composer dictation. Omit it and `dictate` is inert and `micHidden`
+   *  stays true, so a descriptor that never adds a mic is unaffected. */
+  dictation?: AriaDictationOptions;
 }
 
 /** The argument shape every action tolerates. The clone's generic per-item
@@ -1235,6 +1289,16 @@ export interface AriaChatCore {
   widgetPick(s: AriaChatState, arg?: AriaActionArg): AriaChatState;
   /** Answer one QUESTIONNAIRE question. */
   widgetAnswer(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;
+  /** "Done" on the listening row: close the microphone. The session stays live,
+   *  so what the recognizer had already heard is still inserted when it lands. */
+  finishDictation(s: AriaChatState): AriaChatState;
+  /** A dictation outcome (see `AriaDictationOptions.deliver`). Resolves to
+   *  `undefined` — leave the state untouched — for a session that is no longer
+   *  the live one. */
+  dictated(s: AriaChatState, arg?: unknown): AriaChatState | undefined;
   /** Open the mention picker at the category level, listing the site's
    *  installed providers the first time (per business). `undefined` when the
    *  business switched while the list was being fetched. */
@@ -1300,6 +1364,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
   const unavailableText = () => res(
     o.labels?.unavailable ?? `${assistant()} can't reach your Wix account from here.`,
   );
+  const dictationEmptyText = () => res(
+    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 attachUploadingText = () => res(o.labels?.attachUploading ?? "Uploading…");
   const attachFailedText = () => res(o.labels?.attachFailed ?? "Couldn't upload");
   const chipLabels = () => ({ uploading: attachUploadingText(), failed: attachFailedText() });
@@ -1434,6 +1502,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     messages: [], prompts: [], _convId: "", _siteId: "", _pending: "", _pendingRefs: "", _pendingAttach: [],
     _pendingAfter: 0, _pendingId: "", _replyAfter: 0, _srvUsers: 0, _srvAssistants: 0,
     _abortId: "", _turnId: "", stopHidden: true, ok: false,
+    listening: false, micHidden: !o.dictation, listeningHidden: true,
     widget: NO_WIDGET, mention: mentionViewNow,
     attachments: [], attachmentsHidden: true,
   };
@@ -1658,6 +1727,77 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
   let draft = "";
   let draftSeq = 0;
 
+  /** Dictation sessions: a counter minted per `dictate` tap, and the one whose
+   *  result may still land (0 = none).
+   *
+   *  A latch rather than state for the same reason `inFlightSend` is one: the
+   *  result arrives as a fresh dispatch handed the CURRENT state, and the only
+   *  way to tell it is the answer to an older tap — one the recognizer is still
+   *  finishing after the owner started another — is to remember which tap is
+   *  live here. Without it a slow recognizer's late result lands in the
+   *  composer on top of the one the owner is dictating now. */
+  let dictationSession = 0;
+  let dictationLive = 0;
+  /** The live session was ended by the owner's own "Done". Its result is still
+   *  inserted, but an EMPTY one is not reported: they stopped it, and a
+   *  recognizer that does not answer a stop (Android's resolves only at its
+   *  safety cap, 30s later) would otherwise put "Didn't catch that" on screen
+   *  long after anyone was asking. */
+  let dictationStopped = false;
+  /** Sessions the owner ended with "Done" and then SUPERSEDED with a new tap
+   *  before their answers landed. Their words are still theirs: Done promises
+   *  to keep what was heard, and quick re-taps must not break that — on Android
+   *  the new `recognizeOnce` is exactly what settles the old recognizer, so its
+   *  answer arrives right as the new session opens. A SET, not one slot: Done →
+   *  Dictate → Done → Dictate leaves two outstanding, and a single slot dropped
+   *  the first. Each is appended as it lands, silently, without touching the
+   *  live session's `listening`, and leaves the set when it does. */
+  const dictationFinishing = new Set<number>();
+  /** The last dictated insertion: the draft it was built on and the draft it
+   *  produced — see `insertHeard`. Forgotten on any edit, send or fresh chat,
+   *  so it can only ever bridge answers that have not committed yet. */
+  let lastInsert: { from: string; to: string } | null = null;
+  /** The host's answer to `dictation.available`, once asked. `null` until then. */
+  let dictationAvailable: boolean | null = null;
+  const probeDictation = async (): Promise<void> => {
+    if (!o.dictation?.available || dictationAvailable !== null) return;
+    try { dictationAvailable = (await o.dictation.available()) === true; } catch { dictationAvailable = false; }
+  };
+  /** Heard words INTO the draft, never sent: the owner reads what the
+   *  recognizer made of them before it goes anywhere. Appended to what they had
+   *  already typed. Dictation is an edit to the draft, so it moves the draft
+   *  latch exactly as a keystroke does — `withDraft` must not put the old text
+   *  back. */
+  const insertHeard = (s: AriaChatState, heard: string): string => {
+    const current = s.input ?? "";
+    // Two answers can land in the SAME turn — parked Done sessions settling
+    // together — and each `dictated` is handed the state as it was before
+    // either committed. Built on that snapshot, the second would overwrite the
+    // first's words. So when the snapshot is still exactly what the previous
+    // insertion started from, build on what that insertion produced instead.
+    const base = lastInsert && current === lastInsert.from ? lastInsert.to : current;
+    const typed = base.replace(/\s+$/, "");
+    const input = typed ? `${typed} ${heard}` : heard;
+    lastInsert = { from: current, to: input };
+    draft = input;
+    draftSeq += 1;
+    return input;
+  };
+  /** A send or a fresh chat ends dictation. The words belong to the draft the
+   *  owner was writing THEN; a transcript that lands after they sent it, or in
+   *  another conversation's composer, reads as a duplicate draft ready to send
+   *  twice. So the live session is retired (its late answer will be dropped)
+   *  and a still-open microphone is closed. Returns the state fields to spread. */
+  const retireDictation = (): { listening: false } => {
+    dictationFinishing.clear();
+    lastInsert = null;
+    if (dictationLive) {
+      dictationLive = 0;
+      o.dictation?.stop().catch(() => { /* already closed */ });
+    }
+    return { listening: false };
+  };
+
   /** The client-tool exchange the current turn is in the middle of, if any.
    *
    *  While it runs, the agent is WAITING ON US — for the owner's consent, say —
@@ -2037,6 +2177,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // tap that answers a question the owner has already moved past — the same
       // reason a scrollback widget keeps its prose and loses its controls.
       widget: NO_WIDGET,
+      ...retireDictation(),
     };
     inFlightSend = content;
     // Held outside the try so a FAILED send still reports the conversation it
@@ -2313,9 +2454,16 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // `_pending` rather than `turnInFlight` — see `regenerate` for why `status`
     // is not trusted to have been cleared.
     const replyActionsHidden = !(lastReply(s) && !s._pending);
+    // The dictation pair is derived here for the same reason: two exact
+    // negations each maintained by hand is how a screen ends up with both the
+    // mic and "Listening…" on it, or neither.
+    const listening = s.listening === true;
+    const micHidden = !o.dictation || dictationAvailable === false || listening;
+    const listeningHidden = !listening;
     const actioned = s.stopHidden === hidden && s.replyActionsHidden === replyActionsHidden
+      && s.micHidden === micHidden && s.listeningHidden === listeningHidden
       ? s
-      : { ...s, stopHidden: hidden, replyActionsHidden };
+      : { ...s, stopHidden: hidden, replyActionsHidden, micHidden, listeningHidden };
     // The attachment projection rides the same exit, for the same reason: one
     // place that every action's result passes through, so no reducer can hand
     // back a stale copy of the chips. Seeded first, so the very first action of
@@ -2557,6 +2705,9 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // still happened.
       draft = next;
       draftSeq += 1;
+      // The owner's own edit: whatever a previous insertion produced is theirs
+      // to change now, and must not be built on again.
+      lastInsert = null;
       return next === s.input ? s : { ...s, input: next };
     },
 
@@ -2609,6 +2760,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // cancel a poll, so the only way to stop the 2s cadence is to re-arm it
       // slow — do that whenever this interrupted something.
       const wasMidTurn = !!s._pending || s.status === "sending";
+      const retired = retireDictation();
       const slow = (next: AriaChatState): AriaChatState =>
         wasMidTurn && o.poll ? cadence(next, o.poll.idleMs, null) : next;
       try {
@@ -2622,11 +2774,11 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // and the old observed counts back — the fresh chat snapping back to the
         // previous one, which reads as ➕ having done nothing.
         turnSeq += 1;
-        return slow({ ...s, status: "ready", _convId: conversationIdOf(res), _siteId: site, input: "", statusText: "", error: "",
+        return slow({ ...s, ...retired, status: "ready", _convId: conversationIdOf(res), _siteId: site, input: "", statusText: "", error: "",
           _pending: "", _abortId: "", _turnId: "", copyNote: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
       } catch (e) {
         turnSeq += 1;   // see above — a failed create commits state too
-        return slow({ ...s, status: "ready", _convId: "", _siteId: site, input: "", ...failureSlots(e, unavailableText),
+        return slow({ ...s, ...retired, status: "ready", _convId: "", _siteId: site, input: "", ...failureSlots(e, unavailableText),
           _pending: "", _abortId: "", _turnId: "", copyNote: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
       }
     },
@@ -2960,6 +3112,77 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       ? openWidgetUrl(s, s.widget.secondaryUrl)
       : impl.widgetRespond(s, { value: "secondary" }),
 
+    dictate: (s) => {
+      if (!o.dictation || s.listening) return s;
+      const session = ++dictationSession;
+      // Only a session the owner closed with Done can still be live here
+      // (`listening` refuses a tap otherwise), and its answer is still owed.
+      if (dictationLive && dictationStopped) dictationFinishing.add(dictationLive);
+      dictationLive = session;
+      dictationStopped = false;
+      const deliver = (r: Omit<AriaDictationResult, "session">) => {
+        try { o.dictation!.deliver({ session, ...r }); } catch { /* the bundle is gone */ }
+      };
+      // Deliberately not awaited — see `AriaDictationOptions`.
+      o.dictation.listen().then(
+        (r) => deliver({ transcript: r.transcript, cancelled: r.cancelled }),
+        () => deliver({ failed: true }),
+      );
+      // A new attempt retires the previous attempt's own messages, and nothing
+      // else: the status line may be saying "Aria is typing…", which is the
+      // turn's, and the error slot may hold a failed send the owner still needs.
+      return {
+        ...s,
+        listening: true,
+        statusText: s.statusText === dictationEmptyText() ? "" : s.statusText,
+        error: s.error === dictationFailedText() ? "" : s.error,
+      };
+    },
+
+    finishDictation: (s) => {
+      if (!s.listening) return s;
+      // Close the mic without retiring the session: the recognizer answers with
+      // what it had already heard, and dropping that would make "Done" throw the
+      // owner's words away.
+      dictationStopped = true;
+      if (o.dictation) o.dictation.stop().catch(() => { /* already closed */ });
+      return { ...s, listening: false };
+    },
+
+    dictated: (s, arg) => {
+      const r = (arg && typeof arg === "object" ? arg : {}) as Partial<AriaDictationResult>;
+      const session = Number(r.session);
+      // A Done session superseded by a newer tap: keep its words, and nothing
+      // else. Silent on nothing-heard or failure — the owner has moved on to the
+      // next utterance — and `listening` belongs to the live session.
+      if (session && dictationFinishing.has(session)) {
+        dictationFinishing.delete(session);
+        const words = !r.failed && !r.cancelled && typeof r.transcript === "string" ? r.transcript.trim() : "";
+        return words ? { ...s, input: insertHeard(s, words) } : undefined;
+      }
+      // Not the live session: a retired tap's recognizer finishing late (a send
+      // or a new chat ended it), or a result for a worker instance that no
+      // longer exists. Leave everything alone.
+      if (!session || session !== dictationLive) return undefined;
+      dictationLive = 0;
+      const done: AriaChatState = { ...s, listening: false };
+      // Into the error slot only when it is free (or already ours): a failed send
+      // the owner still has to act on outranks a mic that did not start.
+      if (r.failed) return s.error && s.error !== dictationFailedText() ? done : { ...done, error: dictationFailedText() };
+      const heard = typeof r.transcript === "string" ? r.transcript.trim() : "";
+      if (r.cancelled || !heard) {
+        // Neutral, and only when the status line is free: "Aria is typing…"
+        // belongs to a turn in flight and is not ours to overwrite. Silent
+        // after the owner's own Done — see `dictationStopped`.
+        return turnInFlight(s) || dictationStopped ? done : { ...done, statusText: dictationEmptyText() };
+      }
+      return {
+        ...done,
+        input: insertHeard(s, heard),
+        statusText: s.statusText === dictationEmptyText() ? "" : s.statusText,
+      };
+    },
+
     openLink: async (s, arg) => {
       const url = typeof arg === "string" ? arg.trim() : (arg?.url ?? arg?.id ?? "").trim();
       if (!url) return s;
@@ -3215,7 +3438,14 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
   // Every action's result goes through the Stop gate on its way out.
   return {
     initialState,
-    load: (s) => impl.load(s).then(gated),
+    // A `listening: true` that no session in THIS worker owns was persisted by
+    // an earlier process: the recognizer it described is gone, and leaving the
+    // flag up would hide the mic for good.
+    load: async (s) => {
+      const r = await impl.load(s);
+      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),
     newChat: (s) => impl.newChat(s).then(gated),
@@ -3235,6 +3465,9 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     widgetRespond: (s, arg) => impl.widgetRespond(s, arg).then(gated),
     widgetPrimary: (s) => impl.widgetPrimary(s).then(gated),
     widgetSecondary: (s) => impl.widgetSecondary(s).then(gated),
+    dictate: (s) => gated(impl.dictate(s)),
+    finishDictation: (s) => gated(impl.finishDictation(s)),
+    dictated: (s, arg) => { const r = impl.dictated(s, arg); return r ? gated(r) : r; },
     mentionOpen: (s) => impl.mentionOpen(s).then((r) => (r ? gated(r) : r)),
     mentionClose: (s) => gated(impl.mentionClose(s)),
     mentionBack: (s) => gated(impl.mentionBack(s)),

package/templates/retail-store-owner/tier5-src/_shared/collection-contract.ts

@@ -168,6 +168,8 @@ export function projectCollection(source: CollectionRow[], config: CollectionCon
     items: visible.map(row => ({ ...row, collectionId: collectionId(row), collectionTitle: collectionTitle(row, config),
       collectionMeta: [...new Set((config.metadata ?? ['total', 'statusLabel', 'price', 'priceLine', 'dateLine', 'meta']).filter(key => key !== config.subtitle).map(key => scalar(row[key])).filter(Boolean))].join(' · '),
       collectionSelectLabel: prefs.selectedIds.includes(collectionId(row)) ? 'Selected' : 'Select',
+      // The save toggle names the action it WILL take (the service localizes it).
+      collectionSaveLabel: prefs.savedIds.includes(collectionId(row)) ? 'Remove from saved' : 'Save',
       collectionSubtitle: scalar(row[config.subtitle ?? '']) || scalar(row.subtitle) || scalar(row.description) || scalar(row.meta),
       collectionImage: scalar(row[config.image ?? '']), collectionNoImage: !scalar(row[config.image ?? '']), collectionHasImage: !!scalar(row[config.image ?? '']),
       collectionSaved: prefs.savedIds.includes(collectionId(row)), collectionNotSaved: !prefs.savedIds.includes(collectionId(row)), collectionSelected: prefs.selectedIds.includes(collectionId(row)),

package/templates/retail-store-owner/tier5-src/_shared/collection-service.ts

@@ -123,7 +123,12 @@ export function decorateCollection(name: string, def: { state: State; actions?:
       pendingFilter = '';
     }
     const projected = projectCollection(rows, config, prefs, !!backend && config.backendQuery === true, known);
-    projected.items.forEach(row => { row.collectionSelectLabel = row.collectionSelected ? copyParam('collection.selected', 'Selected') : copyParam('collection.select', 'Select'); });
+    projected.items.forEach(row => {
+      row.collectionSelectLabel = row.collectionSelected ? copyParam('collection.selected', 'Selected') : copyParam('collection.select', 'Select');
+      // the save toggle names the action it WILL take for this row. The
+      // old static "Save / unsave" made the owner work out the row's state.
+      row.collectionSaveLabel = row.collectionSaved ? copyParam('collection.unsave', 'Remove from saved') : copyParam('collection.save', 'Save');
+    });
     if (previewId && !rows.some(row => collectionId(row) === previewId)) previewId = '';
     const filterChoices = [{ id: 'all', label: copyParam('collection.all', 'All') }, { id: 'saved', label: copyParam('collection.saved', 'Saved') },
       ...projected.filters.map(label => ({ id: `value:${label}`, label: copyParam(`collection.filter.${label}`, label) }))];

package/templates/retail-store-owner/tier5-src/_shared/owner-account.ts

@@ -0,0 +1,45 @@
+// Pure seams of the owner-lite Account worker — no @himalaya/* imports, so a
+// plain node test can load them without the bundle build's module aliases.
+
+export interface AccountState {
+  status: "loading" | "ready";
+  /** "Name · email", the email alone, or "" (the line collapses). */
+  ownerLine: string;
+  /** "Version 1.2.0 (34)", or "" when the host cannot say. */
+  versionLine: string;
+  /** Why the owner line is empty, when the identity read failed; "" otherwise. */
+  error: string;
+  supportUrl: string;
+  privacyUrl: string;
+  termsUrl: string;
+  /** hiddenPath flags — TRUE hides, so each is phrased negatively. */
+  noSupport: boolean;
+  noPrivacy: boolean;
+  noTerms: boolean;
+}
+
+/** Only absolute http(s) URLs are openable; anything else is treated as absent. */
+export function safeUrl(v: unknown): string {
+  if (typeof v !== "string") return "";
+  const t = v.trim();
+  return /^https?:\/\/[^\s]+$/i.test(t) ? t : "";
+}
+
+/** "Name · email" when both are known, whichever one is when only one is, else "". */
+export function ownerLineOf(name: string, email: string): string {
+  const n = name.trim(), e = email.trim();
+  if (n && e && n !== e) return `${n} · ${e}`;
+  return n || e;
+}
+
+export function shapeAccount(s: Partial<AccountState>): AccountState {
+  const supportUrl = safeUrl(s.supportUrl), privacyUrl = safeUrl(s.privacyUrl), termsUrl = safeUrl(s.termsUrl);
+  return {
+    status: s.status ?? "loading",
+    ownerLine: s.ownerLine ?? "",
+    versionLine: s.versionLine ?? "",
+    error: s.error ?? "",
+    supportUrl, privacyUrl, termsUrl,
+    noSupport: !supportUrl, noPrivacy: !privacyUrl, noTerms: !termsUrl,
+  };
+}

package/templates/retail-store-owner/tier5-src/_shared/owner-preview-demo.ts

@@ -18,6 +18,27 @@ export const DEMO_NOTE =
 
 export const DEMO_SAVE_NOTE = "Demo mode — changes aren’t saved in this preview.";
 
+/** The state patch for a write refused because this is the demo preview. A demo
+ *  refusal is a MODE, not an error: no red error line — the neutral info banner
+ *  (already on screen before the owner typed anything) switches to the save
+ *  note, so the tap still visibly answers. `saveNote` is the (copy-pack) text. */
+export function demoRefusalPatch(saveNote: string = DEMO_SAVE_NOTE): { status: "idle"; error: ""; savedMessage: ""; demoNote: string } {
+  return { status: "idle", error: "", savedMessage: "", demoNote: saveNote || DEMO_SAVE_NOTE };
+}
+
+/** "€1,234.50" / "12,50" / " 10 " → "1234.50" / "12.50" / "10": digits and one
+ *  decimal point — what an editable price field accepts and a price write needs.
+ *  A separator followed by exactly 1–2 digits is the decimal; any other groups. */
+export function editablePrice(raw: string): string {
+  const t = raw.replace(/[^\d.,]/g, "");
+  if (!t) return "";
+  const lastSep = Math.max(t.lastIndexOf("."), t.lastIndexOf(","));
+  if (lastSep >= 0 && /^\d{1,2}$/.test(t.slice(lastSep + 1))) {
+    return `${t.slice(0, lastSep).replace(/[.,]/g, "")}.${t.slice(lastSep + 1)}`;
+  }
+  return t.replace(/[.,]/g, "");
+}
+
 export const DEMO_IDS = ["demo-1", "demo-2", "demo-3"] as const;
 
 export interface DemoProduct {

package/templates/retail-store-owner/tier5-src/himi-owner-lite-account/index.ts

@@ -0,0 +1,68 @@
+// Tier-5 bundle: __HIMI_APP_NAME__ — Account.
+//
+// The Account screen used to be a static SDUI descriptor whose subtitle was the
+// literal "Wix owner (user)" — a role string, not a person. A descriptor cannot
+// know who is signed in; a worker can. This one reads:
+//   • the signed-in Wix user (`getMyData`, the same users.wix.com read
+//     wix-owner-profile uses) → "Name · email" under the title;
+//   • the app's real version through @himalaya/app-info (never a baked literal,
+//     which goes stale the moment the binary is bumped);
+//   • the help / privacy / terms links, which arrive as onAppear params baked
+//     from provisioning.json `identity` — so a branded template ships ITS links,
+//     and `openLink` can only ever open one of those three URLs.
+//
+// Every read is best-effort: an identity or version the host cannot answer
+// collapses its line rather than rendering an error on a settings screen.
+
+import { defineService } from "@himalaya/state";
+import { getMyData } from "@himalaya/wix-users";
+import { displayVersion } from "@himalaya/app-info";
+import { open } from "@himalaya/open-url";
+import { stashCopy, copyTemplate } from "../_shared/himi-copy.js";
+import { ownerLineOf, shapeAccount, type AccountState } from "../_shared/owner-account.js";
+
+type LinkKind = "support" | "privacy" | "terms";
+
+const obj = (v: unknown): Record<string, unknown> => (v && typeof v === "object" ? v as Record<string, unknown> : {});
+
+const svc = defineService<AccountState, {
+  load: (s: AccountState, arg?: unknown) => Promise<AccountState>;
+  openLink: (s: AccountState, arg?: unknown) => Promise<AccountState>;
+}>("himiOwnerLiteAccount", {
+  state: shapeAccount({}),
+  actions: {
+    load: async (s, arg) => {
+      stashCopy(arg);
+      const p = obj(arg);
+      const links = { supportUrl: String(p.supportUrl ?? s.supportUrl), privacyUrl: String(p.privacyUrl ?? s.privacyUrl), termsUrl: String(p.termsUrl ?? s.termsUrl) };
+      let ownerLine = "";
+      // Why the identity line is missing, when it is. Kept in state (the failure is
+      // modelled, not swallowed) but not painted: a settings screen that cannot name
+      // its owner still works, so the line collapses rather than showing an error.
+      let error: string = "";
+      try {
+        const d = await getMyData();
+        // The PROFILE name only — never the userName handle, an account nickname
+        // ("apptestercoowner"): exactly the kind of placeholder this line replaces.
+        const name = [d.profile?.firstName, d.profile?.lastName].filter(Boolean).join(" ");
+        ownerLine = ownerLineOf(name, String(d.email || d.contactEmail || ""));
+      } catch (e) {
+        error = String((e as Error)?.message ?? e);
+      }
+      let versionLine = "";
+      try {
+        const v = await displayVersion();
+        versionLine = v ? copyTemplate("ownerAccount.version", "Version {version}", { version: v }) : "";
+      } catch { /* host without app_info — the row collapses */ }
+      return shapeAccount({ ...s, ...links, status: "ready", ownerLine, versionLine, error });
+    },
+    openLink: async (s, arg) => {
+      const kind = String(obj(arg).kind ?? arg ?? "") as LinkKind;
+      const url = kind === "support" ? s.supportUrl : kind === "privacy" ? s.privacyUrl : kind === "terms" ? s.termsUrl : "";
+      if (url) await open(url);
+      return s;
+    },
+  },
+});
+
+export { svc };

package/templates/retail-store-owner/tier5-src/himi-owner-lite-aria/index.ts

@@ -27,6 +27,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 { put } from "@himalaya/presigned-upload";
 import { alert } from "@himalaya/ui";
@@ -35,6 +36,7 @@ import {
   createAriaChat,
   type AriaActionArg,
   type AriaChatState,
+  type AriaDictationResult,
   type AriaPromptChip,
 } from "../_shared/aria-chat.js";
 import { WIDGET_SUBTREE_SLOT } from "../_shared/aria-generic-widget.js";
@@ -201,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."),
+    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.
     // The CATEGORY labels are not here, deliberately: they are what the
     // reference's `data.type` carries to the model, so they stay English.
@@ -243,6 +247,19 @@ const core = createAriaChat({
     return screenId ? { screenId } : null;
   },
   poll: { action: `${SERVICE}.tick`, fastMs: FAST_MS, idleMs: IDLE_MS },
+  // Composer dictation, on the platform recognizer: SFSpeechRecognizer,
+  // Android SpeechRecognizer, Web Speech. No audio crosses the bridge — only the
+  // final transcript. An empty language means the device's own locale, which is
+  // the owner's, rather than a hardcoded en-US. The screen must declare "speech".
+  //
+  // `svc` is referenced lazily: it is defined below, and `deliver` only ever
+  // runs after an utterance, long after this module has finished evaluating.
+  dictation: {
+    listen: () => recognizeOnce(),
+    stop: () => stopSpeech(),
+    deliver: (r) => { void svc.dictated(r); },
+    available: async () => (await availability()).recognition !== "unavailable",
+  },
   // Photo attachments. The two device capabilities live HERE rather than
   // in the shared core so that only a screen which declares them imports them:
   // `camera` for the picker (it returns the image already re-encoded as JPEG and
@@ -293,6 +310,10 @@ const svc = defineService<AriaChatState, {
   widgetPick: (s: AriaChatState, arg?: AriaActionArg) => AriaChatState;
   widgetQuery: (s: AriaChatState, arg?: AriaActionArg) => AriaChatState;
   widgetAnswer: (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.
+  dictated: (s: AriaChatState, arg?: AriaDictationResult) => AriaChatState | undefined;
   mentionOpen: (s: AriaChatState) => Promise<AriaChatState | undefined>;
   mentionClose: (s: AriaChatState) => AriaChatState;
   mentionBack: (s: AriaChatState) => AriaChatState;
@@ -340,6 +361,13 @@ const svc = defineService<AriaChatState, {
     widgetPick: core.widgetPick,
     widgetQuery: core.widgetQuery,
     widgetAnswer: core.widgetAnswer,
+    // 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
+    // that renders and does nothing.
+    dictate: core.dictate,
+    finishDictation: core.finishDictation,
+    dictated: core.dictated,
     // Mentions: the "@ Mention" control, the two-level picker and the
     // 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.

package/templates/retail-store-owner/tier5-src/himi-owner-lite-ask/index.ts

@@ -111,7 +111,8 @@ const STARTER: Node = {
             props: {
               title: "Ask about your business",
               subtitle: "Try “which products are out of stock”, “unpaid orders”, or “what's coming up”.",
-              icon: "search",
+              // Not `search`: Ask is not search, and a magnifier says it is.
+              icon: "ai",
             },
           },
         },
@@ -129,7 +130,7 @@ const enc = (n: Node): string => encodeSubtree(n as unknown as Parameters<typeof
 const initialState: AskState = {
   status: "idle",
   intent: "",
-  headline: "Ask",
+  headline: "",
   note: "",
   customerNotice: "",
   repairs: "",
@@ -267,7 +268,7 @@ function failed(state: AskState, headline: string, note: string): AskState {
           body: {
             package: "himalaya",
             type: "EmptyState",
-            props: { title: headline, subtitle: note, icon: "search" },
+            props: { title: headline, subtitle: note, icon: "ai" },
           },
         }],
       },