@wix/himalaya-cli 0.1038.0 → 0.1040.0

package/templates/owner-lite/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/owner-lite/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/owner-lite/tier5-src/himi-owner-lite-drawer/index.ts

@@ -7,75 +7,61 @@
 // attention today — and none of that is knowable when the config is authored.
 //
 // Hosting the panel lets the worker answer it at runtime: the live site, per-site
-// counts on the rows that have them, and a "needs attention" line that simply is
-// not there when the count is zero.
+// counts on the rows that have them, and a "needs attention" section that simply
+// is not there when nothing is waiting.
+//
+// The derived fields (initials, the attention total and header, each row's badge
+// and spoken label, the clear-confirmation flags) live in ./logic.ts so they are
+// unit-tested and can only ever agree with each other.
 //
 // Build: node core/dev-server/tier5-bundles-src/build-all.mjs himi-owner-lite-drawer
 //   → core/dev-server/tier5-bundles/himi-owner-lite-drawer.bundle.js
 
 import { defineService } from "@himalaya/state";
 import { serializeForAgent } from "@himalaya/agent";
+import { activeScreenFromInput, attentionRow, navRow, withDerived, type DrawerState } from "./logic.js";
 
-interface Row {
-  id: string;
-  title: string;
-  icon: string;
-  screenId: string;
-  /** Rendered only when non-empty — an owner does not need a "0". */
-  badge: string;
-}
-
-interface DrawerState {
-  siteName: string;
-  siteInitials: string;
-  nav: Row[];
-  /** Rows an owner should look at today; empty ⇒ the section renders nothing. */
-  attention: Row[];
-  attentionLabel: string;
-  /** TRUE when there is nothing to chase. Feeds `hiddenPath`, which hides on a
-   *  TRUTHY value — so the flag is phrased negatively on purpose. */
-  noAttention: boolean;
-}
-
-const nav = (id: string, title: string, icon: string, screenId: string, badge = ""): Row =>
-  ({ id, title, icon, screenId, badge });
-
-/** Recompute the derived attention summary from the rows. */
-function withAttention(s: Omit<DrawerState, "attentionLabel" | "noAttention">): DrawerState {
-  const n = s.attention.length;
-  return {
-    ...s,
-    noAttention: n === 0,
-    attentionLabel: n === 0 ? "All caught up" : `${n} need${n === 1 ? "s" : ""} attention`,
-  };
-}
+/** The shell passes the screen it is showing as worker input, so the drawer can mark
+ *  that destination selected the way the declarative drawer does. */
+const hostActiveScreen = () => activeScreenFromInput((globalThis as { himalaya?: { input?: unknown } }).himalaya?.input);
 
 const drawer = defineService<DrawerState, {
-  /** Re-read the live site + counts. */
-  refresh: (s: DrawerState) => DrawerState;
-  /** Clear the attention list — proves the section disappears, not just empties. */
+  /** Re-read the active screen from host input (root onAppear). An explicit
+   *  `{ screenId }` wins, for a host that pushes the change instead. */
+  syncActive: (s: DrawerState, args?: { screenId?: string }) => DrawerState;
+  /** First tap on "Mark all handled": ask before hiding anything. */
+  askClearAttention: (s: DrawerState) => DrawerState;
+  /** The owner backed out of the confirmation. */
+  cancelClearAttention: (s: DrawerState) => DrawerState;
+  /** Confirmed: clear the attention list — the section disappears, not just empties. */
   clearAttention: (s: DrawerState) => DrawerState;
 }>("drawer", {
-  state: withAttention({
+  state: withDerived({
     siteName: "My Site",
-    siteInitials: "MS",
     nav: [
-      nav("drawer_home", "Home", "home", "himi_owner_lite_home"),
+      navRow("drawer_home", "Home", "home", "himi_owner_lite_home"),
       // Between Home and Manage deliberately: analytics answers "how is the
       // business doing", which sits with the dashboard, not with the per-entity
       // management areas below it.
-      nav("drawer_analytics", "Analytics", "chart", "himi_owner_lite_analytics"),
-      nav("drawer_manage", "Manage", "grid", "himi_owner_lite_manage"),
-      nav("drawer_account", "Account", "person", "himi_owner_lite_account"),
+      navRow("drawer_analytics", "Analytics", "chart", "himi_owner_lite_analytics"),
+      navRow("drawer_manage", "Manage", "grid", "himi_owner_lite_manage"),
+      navRow("drawer_account", "Account", "person", "himi_owner_lite_account"),
     ],
     attention: [
-      nav("att_orders", "Orders", "cart", "himi_owner_lite_orders", "3"),
-      nav("att_appts", "Appointments", "calendar", "himi_owner_lite_appointments", "1"),
+      attentionRow("att_orders", "Orders", "cart", "himi_owner_lite_orders", 3),
+      attentionRow("att_appts", "Appointments", "calendar", "himi_owner_lite_appointments", 1),
     ],
+    confirmingClear: false,
+    activeScreenId: hostActiveScreen(),
   }),
   actions: {
-    refresh: (s) => snap(withAttention({ ...s, attention: [...s.attention] })),
-    clearAttention: (s) => snap(withAttention({ ...s, attention: [] })),
+    syncActive: (s, args) => snap(withDerived({
+      ...s,
+      activeScreenId: typeof args?.screenId === "string" ? args.screenId : hostActiveScreen(),
+    })),
+    askClearAttention: (s) => snap(withDerived({ ...s, confirmingClear: true })),
+    cancelClearAttention: (s) => snap(withDerived({ ...s, confirmingClear: false })),
+    clearAttention: (s) => snap(withDerived({ ...s, attention: [], confirmingClear: false })),
   },
 });
 

package/templates/owner-lite/tier5-src/himi-owner-lite-drawer/logic.ts

@@ -0,0 +1,102 @@
+// himi-owner-lite DRAWER — pure derivations, kept out of index.ts so they are
+// unit-testable without booting a worker.
+//
+// Everything a reader of the panel compares lives here, so the pieces can only ever
+// agree: the header counts ITEMS summed from the same numbers the badges show (it
+// used to count rows, and read "2 need attention" over badges of 3 and 1), and each
+// row's spoken label is built from those same numbers.
+
+export interface Row {
+  id: string;
+  title: string;
+  /** Design-system icon name for the row's leading glyph. */
+  icon: string;
+  screenId: string;
+  /** Items waiting on this row; 0 for a plain destination. */
+  count: number;
+  /** The badge text — the count, or "" (a destination shows no badge). */
+  badge: string;
+  /** The badge read on its own, for a screen reader that keeps a labelled row's
+   *  children reachable (iOS): "3 need attention". "" when there is no badge. */
+  badgeLabel: string;
+  /** What a screen reader announces for the whole row. */
+  a11yLabel: string;
+  /** This row is the screen the owner is on. Only destinations can be. */
+  selected: boolean;
+  /** `!selected`, for `hiddenPath` (which hides on a TRUTHY value). */
+  notSelected: boolean;
+}
+
+/** The authored part of the state; everything else is derived by `withDerived`. */
+export interface DrawerCore {
+  siteName: string;
+  nav: Row[];
+  attention: Row[];
+  /** The owner tapped "Mark all handled" and has not confirmed or cancelled yet. */
+  confirmingClear: boolean;
+  /** The screen the shell is showing, passed in as worker input; "" when unknown. */
+  activeScreenId: string;
+}
+
+export interface DrawerState extends DrawerCore {
+  siteInitials: string;
+  attentionTotal: number;
+  attentionLabel: string;
+  /** TRUE when there is nothing to chase. Feeds `hiddenPath`, which hides on a
+   *  TRUTHY value — so the flag is phrased negatively on purpose. */
+  noAttention: boolean;
+  /** Hides the inline confirmation (same negative phrasing, same reason). */
+  noConfirmClear: boolean;
+  /** The confirmation question, naming how much will be hidden. */
+  clearPrompt: string;
+}
+
+const needs = (n: number) => `${n} need${n === 1 ? "s" : ""} attention`;
+
+export const navRow = (id: string, title: string, icon: string, screenId: string): Row =>
+  ({ id, title, icon, screenId, count: 0, badge: "", badgeLabel: "", a11yLabel: title, selected: false, notSelected: true });
+
+export const attentionRow = (id: string, title: string, icon: string, screenId: string, count: number): Row => {
+  const n = Math.max(0, Math.floor(count));
+  return { id, title, icon, screenId, count: n, badge: n > 0 ? String(n) : "", badgeLabel: n > 0 ? needs(n) : "", a11yLabel: n > 0 ? `${title}, ${needs(n)}` : title, selected: false, notSelected: true };
+};
+
+/** Up to two initials from the site name: "Pottery Studio" → "PS". */
+export function initialsOf(name: string): string {
+  const words = name.trim().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return "?";
+  return words.slice(0, 2).map((w) => [...w][0]!.toUpperCase()).join("");
+}
+
+/** Recompute every derived field. Rows with nothing waiting are dropped, so a
+ *  cleared or all-zero section hides instead of listing zeros. */
+export function withDerived(core: DrawerCore): DrawerState {
+  const attention = core.attention.filter((row) => row.count > 0);
+  const active = core.activeScreenId;
+  const nav = core.nav.map((row) => {
+    const selected = active !== "" && row.screenId === active;
+    return { ...row, selected, notSelected: !selected };
+  });
+  const total = attention.reduce((sum, row) => sum + row.count, 0);
+  const confirmingClear = core.confirmingClear && total > 0;
+  return {
+    ...core,
+    nav,
+    attention,
+    confirmingClear,
+    siteInitials: initialsOf(core.siteName),
+    attentionTotal: total,
+    attentionLabel: total === 0
+      ? "All caught up"
+      : `${total} item${total === 1 ? "" : "s"} ${total === 1 ? "needs" : "need"} attention`,
+    noAttention: total === 0,
+    noConfirmClear: !confirmingClear,
+    clearPrompt: total === 1 ? "Hide this reminder?" : `Hide these ${total} reminders?`,
+  };
+}
+
+/** The active screen from the worker's host input (`himalaya.input.activeScreenId`). */
+export function activeScreenFromInput(input: unknown): string {
+  const v = (input as { activeScreenId?: unknown } | undefined)?.activeScreenId;
+  return typeof v === "string" ? v : "";
+}

package/templates/podcast-creator-owner/config.ts

@@ -37,7 +37,7 @@ export default defineApp({
     actions: "http://localhost:8190/v1/actions",
     sync: "http://localhost:8190/v1/sync",
   },
-  capabilities: ["live_activity","push","share","secure_storage","open_url","local_database","clipboard","ui","camera","presigned_upload"],
+  capabilities: ["live_activity","push","share","secure_storage","open_url","local_database","clipboard","ui","speech","camera","presigned_upload"],
   designTokensPath: "./tokens.json",
   navigation: {
     "navKind": "responsive",