@hienlh/ppm 0.23.6 → 0.23.8

package/src/web/lib/new-chat-prepare-client.ts

@@ -0,0 +1,167 @@
+/**
+ * Client for `POST /chat/prepare` — the single request a sessionless chat tab fires on
+ * mount. One in-flight (or recently settled) promise per tab id; everything the response
+ * carries is fanned out into the caches each part would otherwise have fetched
+ * separately (settings, provider list, slash items, tags, usage, the account claim), so
+ * none of those fire their own network call while this one covers them.
+ *
+ * The promise is kept for a while after it settles rather than deleted the instant it
+ * resolves — a consumer that mounts a beat later (useUsage's deferred timer, a slash
+ * picker opened right after) still joins the same answer instead of starting a
+ * redundant request.
+ *
+ * Two facts outlive that join window, because they must not be re-learned by asking the
+ * server again: that the tab's current sessionless stretch is already prepared (so a
+ * remount does not POST — and consume an account pick — a second time), and that its
+ * pick came back with no usable account (so the claim hook does not POST `/pick` to be
+ * told the same thing). Both are dropped by `forgetPrepare` once the tab has a session.
+ */
+import { api, projectUrl } from "./api-client";
+import { CHAT_PREPARATION_TIMEOUT_MS, seedChatProviders, type ChatProviderInfo } from "./chat-preparation-cache";
+import { writeChatPreparationSettings, writeChatProviders } from "./chat-preference-local-cache";
+import { projectCacheId, type ProjectCacheRef } from "./browser-cache/cache-keys";
+import { seedSlashItems, registerPendingSlash, type SlashItemsPayload } from "./slash-items-cache";
+import { useSessionListStore, type SessionTagsState } from "@/stores/session-list-store";
+import { seedUsage, usageScopeKey } from "@/hooks/use-usage";
+import { applyAccountClaim } from "@/hooks/use-chat-account-claim";
+import type { ChatPreparationSettings } from "../../shared/chat-preparation-settings";
+import type { UsageInfo } from "../../types/chat";
+
+export interface PickedAccount { id: string; label: string | null }
+export type PrepareDraft = { content: string; attachments: string; updatedAt: string } | null;
+
+export interface PreparedChat {
+  resolvedProviderId: string;
+  providerId: string;
+  settings: ChatPreparationSettings;
+  providers: ChatProviderInfo[];
+  pickedAccount: PickedAccount | null | "timeout" | "skipped";
+  usage: (UsageInfo & { lastFetchedAt?: string }) | null;
+  draft: PrepareDraft;
+  tags: SessionTagsState | null;
+  slash: SlashItemsPayload | null;
+}
+
+export interface PrepareRequestBody {
+  providerId?: string;
+  focusedProvider?: string;
+  skipPick?: boolean;
+}
+
+/** Sends the prepare request. Replaceable in tests, which otherwise depend on whichever
+ * `api-client` module another test file in the same process left mocked. */
+export type PrepareTransport = (path: string, body: PrepareRequestBody, signal: AbortSignal) => Promise<PreparedChat>;
+const defaultTransport: PrepareTransport = (path, body, signal) => api.post<PreparedChat>(path, body, { signal });
+let transport: PrepareTransport = defaultTransport;
+
+const inFlight = new Map<string, Promise<PreparedChat>>();
+/** Tabs whose current sessionless stretch already has a successful prepare. */
+const prepared = new Set<string>();
+/** Tab id → the provider for which prepare's pick found no usable account. */
+const pickedNoAccount = new Map<string, string>();
+
+/** Idempotent per tab id — a second call before the first settles (or within its
+ * post-settle join window) returns the same promise instead of firing a new POST. */
+export function startPrepare(tabId: string, project: ProjectCacheRef, body: PrepareRequestBody): Promise<PreparedChat> {
+  const existing = inFlight.get(tabId);
+  if (existing) return existing;
+  const promise = transport(`${projectUrl(project.name)}/chat/prepare`, body, AbortSignal.timeout(CHAT_PREPARATION_TIMEOUT_MS))
+    .then((result) => {
+      // A tab that got its session (or was forgotten) while this was in flight has
+      // moved on: its caches may still be seeded, but its claim and flags must not be.
+      if (inFlight.get(tabId) === promise) {
+        prepared.add(tabId);
+        applyPrepared(tabId, project, result);
+      } else {
+        applyShared(project, result);
+      }
+      return result;
+    });
+  inFlight.set(tabId, promise);
+  // Only worth registering when the provider is already known — a still-pending tab's
+  // composer will not call fetchSlashItems until the gate resolves it, by which point
+  // this same promise has already seeded the cache directly (see applyPrepared).
+  if (body.providerId) {
+    registerPendingSlash(project.name, body.providerId, promise.then((result) => result.slash, () => null));
+  }
+  // Both branches handled: a failed prepare is reported to whoever awaits `promise`,
+  // and this bookkeeping chain must not surface it a second time as unhandled.
+  const expire = () => {
+    setTimeout(() => { if (inFlight.get(tabId) === promise) inFlight.delete(tabId); }, CHAT_PREPARATION_TIMEOUT_MS);
+  };
+  promise.then(expire, expire);
+  return promise;
+}
+
+/** The tab's in-flight (or recently settled) prepare, or undefined when none was started. */
+export function getPrepare(tabId: string | undefined): Promise<PreparedChat> | undefined {
+  return tabId ? inFlight.get(tabId) : undefined;
+}
+
+/** Whether this tab's current sessionless stretch was already prepared successfully —
+ * true even after the join window, so a remount does not prepare (and pick) again. */
+export function isPrepared(tabId: string): boolean {
+  return prepared.has(tabId);
+}
+
+/** True when this tab's prepare already asked for an account on `provider` and was told
+ * none is usable. That answer is final for the tab: asking `/pick` again would either get
+ * the same null or, worse, advance another provider's round-robin. */
+export function prepareFoundNoAccount(tabId: string, provider: string): boolean {
+  return pickedNoAccount.get(tabId) === provider;
+}
+
+/**
+ * Drops everything kept for a tab once it has a session. From then on nothing may join
+ * the old answer: a design tab's `/clear` remounts under the same tab id, and joining
+ * would restore the `__new__` draft that was just sent and reapply stale settings.
+ */
+export function forgetPrepare(tabId: string): void {
+  inFlight.delete(tabId);
+  prepared.delete(tabId);
+  pickedNoAccount.delete(tabId);
+}
+
+/** Test-only escape hatch: tab ids are reused across `it()` blocks that share a
+ * fixture, and this module's dedupe is keyed on them for real minutes at a time in
+ * production. Production code never calls this. */
+export function __clearPrepareForTest(): void {
+  inFlight.clear();
+  prepared.clear();
+  pickedNoAccount.clear();
+}
+
+/** Test-only: what the join window's own timer does after 30 s, without the wait. */
+export function __expirePrepareJoinForTest(tabId: string): void {
+  inFlight.delete(tabId);
+}
+
+/** Test-only: route the request through `fn` (or back to the real API with null). */
+export function __setPrepareTransportForTest(fn: PrepareTransport | null): void {
+  transport = fn ?? defaultTransport;
+}
+
+/** The caches keyed by project or provider — true for any tab of that project. */
+function applyShared(project: ProjectCacheRef, result: PreparedChat): void {
+  writeChatPreparationSettings(result.settings);
+  writeChatProviders(projectCacheId(project), result.providers);
+  seedChatProviders(project.name, result.providers);
+  if (result.tags) useSessionListStore.getState().seedTags(project, result.tags);
+  if (result.slash) seedSlashItems(project, result.providerId, result.slash);
+}
+
+function applyPrepared(tabId: string, project: ProjectCacheRef, result: PreparedChat): void {
+  applyShared(project, result);
+
+  // "timeout"/"skipped" carry no account to apply; only "timeout" leaves the claim hook
+  // to pick again. A real pick is written into the tab's metadata, and an explicit null
+  // (nothing usable, or a provider without managed accounts) is remembered as final.
+  if (result.pickedAccount === null) pickedNoAccount.set(tabId, result.providerId);
+  const claimed = result.pickedAccount && result.pickedAccount !== "timeout" && result.pickedAccount !== "skipped"
+    ? result.pickedAccount : null;
+  applyAccountClaim(tabId, result.providerId, claimed);
+
+  if (result.usage) {
+    seedUsage(usageScopeKey(project.name, result.providerId, undefined, claimed?.id), result.usage, result.usage.lastFetchedAt ?? null, claimed?.id);
+  }
+}

package/src/web/lib/new-chat-provider.ts

@@ -1,8 +1,3 @@
-import type { AISettings } from "./api-settings";
-
-/** The source is captured when the tab opens, before another panel can gain focus. */
-export function resolveNewChatProvider(settings: AISettings, focusedProvider?: string): string {
-  return settings.new_chat_provider_mode === "follow-focus" && focusedProvider
-    ? focusedProvider
-    : settings.default_provider || "claude";
-}
+// Moved to src/shared so the server's /chat/prepare endpoint can resolve a provider with the
+// exact same logic. Re-exported here so existing importers keep working unchanged.
+export { resolveNewChatProvider } from "../../shared/new-chat-provider.ts";

package/src/web/lib/search-select-rows.ts

@@ -0,0 +1,55 @@
+/**
+ * The rows a searchable select shows for one query.
+ *
+ * Pure, and in `lib` rather than beside the component, because importing the
+ * component reaches the sheet's hooks, which want a DOM — the decisions here are
+ * testable without one.
+ *
+ * The match is a case-insensitive substring of the whole label, the same one the
+ * checkout quick pick makes. Not a prefix: the lists this serves are names that
+ * agree for most of their length — `fix/NX-5175-…` branches, `nxsys-backend-nx5833`
+ * checkouts — and the part anyone types is the part that differs.
+ *
+ * A heading is emitted only when something under it survived the filter, the rule
+ * `git-ref-picker.ts` follows too: a heading over nothing reads as a list that failed
+ * to load. Groups keep the order they first appear in over the *whole* list, so a
+ * filter that empties the first group does not reorder the rest.
+ */
+import type { ElementType } from "react";
+
+export interface SearchSelectItem {
+  value: string;
+  /** Shown on the row and on the trigger, and what the filter matches. */
+  label: string;
+  /** The heading this row is listed under. Items with none get no heading. */
+  group?: string;
+  icon?: ElementType;
+  /** Short muted text at the end of the row — `current`, say. */
+  hint?: string;
+  /** Tooltip, for when the label is a shortened form of something longer. */
+  title?: string;
+}
+
+export type SearchSelectRow =
+  | { kind: "separator"; label: string }
+  | { kind: "item"; item: SearchSelectItem };
+
+export function searchRows(items: SearchSelectItem[], query: string): SearchSelectRow[] {
+  const q = query.trim().toLowerCase();
+  const matched = q ? items.filter((i) => i.label.toLowerCase().includes(q)) : items;
+  const rows: SearchSelectRow[] = [];
+
+  for (const group of new Set(items.map((i) => i.group))) {
+    const inGroup = matched.filter((i) => i.group === group);
+    if (!inGroup.length) continue;
+    if (group !== undefined) rows.push({ kind: "separator", label: group });
+    for (const item of inGroup) rows.push({ kind: "item", item });
+  }
+
+  return rows;
+}
+
+/** Where a value sits in the rows, or -1 — what opens the list on the current choice. */
+export function rowIndexOf(rows: SearchSelectRow[], value: string): number {
+  return rows.findIndex((r) => r.kind === "item" && r.item.value === value);
+}

package/src/web/lib/session-list-merge.ts

@@ -0,0 +1,88 @@
+/**
+ * Pure list operations for the shared session store — sorting, pin
+ * injection, dedupe, id replacement and the bulk-delete cutoff — kept out of
+ * the zustand module so they can be unit tested without importing a store
+ * that reads localStorage at module scope (which throws under bun:test).
+ */
+import { compareSessionsByActivity, type SessionInfo } from "../../types/chat";
+
+export function sortSessions(sessions: SessionInfo[]): SessionInfo[] {
+  return [...sessions].sort(compareSessionsByActivity);
+}
+
+/** Drops every id after its first occurrence, keeping list order otherwise. */
+export function dedupeById(sessions: SessionInfo[]): SessionInfo[] {
+  const seen = new Set<string>();
+  const out: SessionInfo[] = [];
+  for (const s of sessions) {
+    if (seen.has(s.id)) continue;
+    seen.add(s.id);
+    out.push(s);
+  }
+  return out;
+}
+
+/** Insert or replace a session by id, then resort — used for both a locally
+ * created/forked session and one a background sync fetched. */
+export function upsertSession(sessions: SessionInfo[], session: SessionInfo): SessionInfo[] {
+  const idx = sessions.findIndex((s) => s.id === session.id);
+  const next = idx === -1
+    ? [...sessions, session]
+    : sessions.map((s, i) => (i === idx ? { ...s, ...session } : s));
+  return sortSessions(next);
+}
+
+export function removeSession(sessions: SessionInfo[], id: string): SessionInfo[] {
+  return sessions.filter((s) => s.id !== id);
+}
+
+export function renameSession(sessions: SessionInfo[], id: string, title: string): SessionInfo[] {
+  return sessions.map((s) => (s.id === id ? { ...s, title } : s));
+}
+
+/** The provider adopted its own id for a session PPM minted — swap it in place
+ * so history rows and every open tab keep pointing at the same row. If the
+ * new id is somehow already present (a rare migrate-twice race), the stale
+ * row under the old id is dropped rather than showing the same chat twice. */
+export function replaceSessionId(sessions: SessionInfo[], oldId: string, newId: string): SessionInfo[] {
+  if (oldId === newId) return sessions;
+  const hasNew = sessions.some((s) => s.id === newId);
+  const base = hasNew ? sessions.filter((s) => s.id !== oldId) : sessions;
+  return base.map((s) => (s.id === oldId ? { ...s, id: newId } : s));
+}
+
+export function setPinned(sessions: SessionInfo[], id: string, pinned: boolean): SessionInfo[] {
+  return sortSessions(sessions.map((s) => (s.id === id ? { ...s, pinned } : s)));
+}
+
+export function setSessionTag(
+  sessions: SessionInfo[],
+  id: string,
+  tag: { id: number; name: string; color: string } | null,
+): SessionInfo[] {
+  return sessions.map((s) => (s.id === id ? { ...s, tag } : s));
+}
+
+/** A deleted tag stops applying to any cached row that carried it — the
+ * server already cleared it, so cached rows must not keep showing a chip for
+ * a tag that no longer exists. */
+export function clearDeletedTag(sessions: SessionInfo[], tagId: number): SessionInfo[] {
+  return sessions.map((s) => (s.tag?.id === tagId ? { ...s, tag: null } : s));
+}
+
+function sessionActivityTime(session: SessionInfo): number {
+  const updated = session.updatedAt ? Date.parse(session.updatedAt) : NaN;
+  if (Number.isFinite(updated)) return updated;
+  const created = Date.parse(session.createdAt);
+  return Number.isFinite(created) ? created : 0;
+}
+
+/** An approximation of the server's bulk delete, applied to the cached rows until the
+ * re-sync that follows it lands: pinned rows survive, everything else is dropped once its
+ * last activity is older than `days`. The server's rule is narrower — it goes by
+ * `createdAt`, lists only the default provider's sessions and keeps any session that has
+ * forks — so this can briefly hide a row the server kept; the re-sync brings it back. */
+export function removeOlderThan(sessions: SessionInfo[], days: number, now: number = Date.now()): SessionInfo[] {
+  const cutoff = now - days * 24 * 60 * 60 * 1000;
+  return sessions.filter((s) => s.pinned || sessionActivityTime(s) >= cutoff);
+}

package/src/web/lib/slash-items-cache.ts

@@ -1,67 +1,131 @@
-import { api, projectUrl } from "@/lib/api-client";
+import { api, projectUrl } from "./api-client";
 import type { SlashItem } from "@/components/chat/slash-command-picker";
+import { idbGetEntry, idbSet } from "./browser-cache/idb-keyval-cache";
+import { readChatPreparationSettings } from "./chat-preference-local-cache";
+import { projectCacheId, slash as slashKey, type ProjectCacheRef } from "./browser-cache/cache-keys";
+import { registerProjectHydrator } from "./browser-cache/project-cache-hydration";
+import { registerCacheReset } from "./browser-cache/wipe-browser-caches";
 
-export interface SlashItemsPayload {
-  items: SlashItem[];
-  recentNames: string[];
+export interface SlashItemsPayload { items: SlashItem[]; recentNames: string[] }
+export const SLASH_ITEMS_TTL_MS = 30 * 60_000;
+type Entry = { data?: SlashItemsPayload; promise?: Promise<SlashItemsPayload>; expiresAt: number };
+const projects = new Map<string, Entry>();
+const providers = new Map<string, SlashItemsPayload>();
+const listeners = new Set<() => void>();
+const keyFor = (project: string, provider = "claude") => JSON.stringify([project, provider]);
+
+/** Provider-wide skills are immediately usable; project overrides stay local. */
+export function getCachedSlashItems(project: string, provider = "claude"): SlashItemsPayload | undefined {
+  return projects.get(keyFor(project, provider))?.data ?? providers.get(provider);
+}
+export function subscribeSlashItems(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => { listeners.delete(listener); };
+}
+
+function fetchFromServer(project: string, provider: string, sessionId?: string): Promise<SlashItemsPayload> {
+  const query = new URLSearchParams({ providerId: provider });
+  if (sessionId) query.set("sessionId", sessionId);
+  return api.get<SlashItemsPayload>(`${projectUrl(project)}/chat/slash-items?${query}`)
+    .then((data) => ({ items: data.items ?? [], recentNames: data.recentNames ?? [] }));
+}
+
+/** Owns `entry.promise` for `key` until `request` settles — shared by a plain network
+ * fetch and a prepare-registered join so both update the provider-wide entry and
+ * notify listeners the same way once they land. */
+function settle(key: string, entry: Entry, provider: string, request: Promise<SlashItemsPayload>): Promise<SlashItemsPayload> {
+  const promise = request.then((payload) => {
+    if (projects.get(key) === entry) {
+      entry.data = payload;
+      entry.expiresAt = Date.now() + SLASH_ITEMS_TTL_MS;
+      providers.set(provider, { items: payload.items.filter((item) => item.scope !== "project"), recentNames: [] });
+      listeners.forEach((listener) => listener());
+    }
+    return payload;
+  }).finally(() => { if (entry.promise === promise) entry.promise = undefined; });
+  entry.promise = promise;
+  return promise;
+}
+
+export function fetchSlashItems(project: string, provider = "claude", sessionId?: string): Promise<SlashItemsPayload> {
+  const key = keyFor(project, provider);
+  const entry = projects.get(key);
+  if (entry?.promise) return entry.promise;
+  if (entry?.data && Date.now() < entry.expiresAt) return Promise.resolve(entry.data);
+  const owner = entry ?? { expiresAt: 0 };
+  if (!entry) projects.set(key, owner);
+  return settle(key, owner, provider, fetchFromServer(project, provider, sessionId));
 }
 
 /**
- * Per-project cache for the slash-command / skill list.
- *
- * The list is identical for every chat tab in a project but was fetched once per
- * `MessageInput` mount — 23 KB per newly opened tab. The slash picker renders
- * `null` until the list resolves, so that fetch sat directly in front of the
- * first `/` the user typed in every new tab.
+ * Joins a `/chat/prepare` request already in flight for this (project, provider), so the
+ * composer's own mount-time `fetchSlashItems` reuses its slash part instead of firing a
+ * second GET. Falls back to the real request when prepare's slash part came back null
+ * (its own budget ran out server-side).
  *
- * Caches the in-flight promise (not just the result) so simultaneous mounts share
- * one request. Session-scoped: a reload starts empty.
- *
- * Keyed by project AND session, because the list is no longer identical across a
- * project's tabs: a provider that owns its skill runtime answers for itself, so a
- * codex tab and a Claude tab in one project get different lists — and two codex
- * tabs can differ too when they are bound to different accounts.
+ * Only useful for the same key a concurrent `fetchSlashItems` will actually be called
+ * with — a caller that does not yet know the resolved provider has nothing to register.
  */
-const CACHE_TTL_MS = 60_000;
-const cache = new Map<string, { promise: Promise<SlashItemsPayload>; expiresAt: number }>();
-
-export function fetchSlashItems(
-  projectName: string,
-  providerId?: string,
-  sessionId?: string,
-): Promise<SlashItemsPayload> {
-  const key = `${projectName}\0${providerId ?? ""}\0${sessionId ?? ""}`;
-  const cached = cache.get(key);
-  if (cached && Date.now() < cached.expiresAt) return cached.promise;
-
-  const query = new URLSearchParams();
-  if (providerId) query.set("providerId", providerId);
-  if (sessionId) query.set("sessionId", sessionId);
-  const qs = query.size > 0 ? `?${query}` : "";
+export function registerPendingSlash(project: string, provider: string, promise: Promise<SlashItemsPayload | null>): void {
+  const key = keyFor(project, provider);
+  const existing = projects.get(key);
+  if (existing?.promise || (existing?.data && Date.now() < existing.expiresAt)) return;
+  const owner = existing ?? { expiresAt: 0 };
+  if (!existing) projects.set(key, owner);
+  settle(key, owner, provider, promise.then((payload) => payload ?? fetchFromServer(project, provider)));
+}
 
-  const p = api
-    .get<SlashItemsPayload>(`${projectUrl(projectName)}/chat/slash-items${qs}`)
-    .then((data) => ({ items: data.items ?? [], recentNames: data.recentNames ?? [] }))
-    .catch((e) => {
-      // Don't cache failures — the next mount should retry.
-      if (cache.get(key)?.promise === p) cache.delete(key);
-      throw e;
-    });
+/** Seeds a provider's slash list straight from a `/chat/prepare` response — no GET. */
+export function seedSlashItems(project: ProjectCacheRef, provider: string, payload: SlashItemsPayload): void {
+  const key = keyFor(project.name, provider);
+  projects.set(key, { data: payload, expiresAt: Date.now() + SLASH_ITEMS_TTL_MS });
+  providers.set(provider, { items: payload.items.filter((item) => item.scope !== "project"), recentNames: [] });
+  listeners.forEach((listener) => listener());
+  void idbSet(slashKey(projectCacheId(project), provider), payload);
+}
 
-  cache.set(key, { promise: p, expiresAt: Date.now() + CACHE_TTL_MS });
-  return p;
+export function clearSlashItemsCache(project?: string): void {
+  if (!project) { projects.clear(); providers.clear(); return; }
+  for (const [key, entry] of projects) projects.set(key, { data: entry.data, expiresAt: 0 });
 }
 
 /**
- * Drop cached lists so the next mount refetches. Called when the user hits the
- * refresh button in the picker, which also invalidates the server-side cache.
+ * Fills a (project, provider) entry from IndexedDB — stale-while-revalidate.
+ *
+ * The list is shown as soon as it lands, but it keeps the age it was stored with
+ * (`expiresAt = at + TTL`), so a list written days ago is already expired: the next
+ * `fetchSlashItems` or `registerPendingSlash` still refreshes it instead of trusting
+ * it for another half hour. An entry that already has a request in flight but no data
+ * yet — the normal order on a project switch, where the tabs mount (and register their
+ * prepare) right after hydration starts — still gets the data to show meanwhile; only
+ * an entry that already holds data is left alone.
  */
-export function clearSlashItemsCache(projectName?: string): void {
-  if (!projectName) { cache.clear(); return; }
-  // One project now holds several keys (one per provider/session), so a targeted
-  // refresh has to drop every entry belonging to it, not just an exact match.
-  const prefix = `${projectName}\0`;
-  for (const key of cache.keys()) {
-    if (key.startsWith(prefix)) cache.delete(key);
+async function hydrateSlashEntry(project: ProjectCacheRef, provider: string): Promise<void> {
+  const cached = await idbGetEntry<SlashItemsPayload>(slashKey(projectCacheId(project), provider));
+  if (!cached || !Array.isArray(cached.data?.items)) return;
+  const key = keyFor(project.name, provider);
+  const entry = projects.get(key);
+  if (entry?.data) return; // a network answer (or a seed) already landed first
+  const expiresAt = cached.at + SLASH_ITEMS_TTL_MS;
+  if (entry) {
+    entry.data = cached.data;
+    entry.expiresAt = expiresAt;
+  } else {
+    projects.set(key, { data: cached.data, expiresAt });
   }
+  listeners.forEach((listener) => listener());
 }
+
+// Warms the list on project switch, ahead of any tab mounting, for the providers a
+// new tab is most likely to open on: "claude" and whatever the cached settings name as
+// the default. A tab on any other provider hydrates the ordinary way, through its own
+// `fetchSlashItems` call.
+registerProjectHydrator(async (project) => {
+  const likely = new Set(["claude", readChatPreparationSettings()?.default_provider ?? "claude"]);
+  await Promise.all([...likely].map((provider) => hydrateSlashEntry(project, provider)));
+});
+
+registerCacheReset(() => {
+  projects.clear();
+  providers.clear();
+});

package/src/web/lib/temperature.ts

@@ -0,0 +1,27 @@
+/**
+ * Temperature display unit — Mission Center's one Preferences setting that changes
+ * what a number MEANS rather than how often it is fetched.
+ *
+ * Every collector reports Celsius, so this is purely a display conversion and the
+ * conversion stays here rather than in six detail panels. `undefined` survives
+ * untouched: the whole System Monitor treats it as "this host cannot measure
+ * that", and a missing sensor must never render as 32 °F.
+ */
+export type TempUnit = "c" | "f";
+
+export function toFahrenheit(celsius: number): number {
+  return celsius * 9 / 5 + 32;
+}
+
+/** A temperature ready to render, or undefined when there is nothing to show. */
+export function formatTemp(celsius: number | undefined, unit: TempUnit): string | undefined {
+  if (celsius === undefined || !Number.isFinite(celsius)) return undefined;
+  return unit === "f"
+    ? `${toFahrenheit(celsius).toFixed(1)} °F`
+    : `${celsius.toFixed(1)} °C`;
+}
+
+/** A value off localStorage is untrusted the same way one off the wire is. */
+export function parseTempUnit(value: unknown): TempUnit {
+  return value === "f" ? "f" : "c";
+}

package/src/web/lib/voice-wav.ts

@@ -0,0 +1,69 @@
+/**
+ * Turning what `MediaRecorder` produced into what whisper.cpp reads.
+ *
+ * The browser records Opus in WebM (Chrome), Opus in Ogg (Firefox) or AAC in
+ * MP4 (Safari); whisper.cpp reads wav, flac, mp3 and Vorbis-ogg — so none of
+ * them, and converting on the host would mean requiring ffmpeg there. The
+ * browser already has a decoder for its own recording, so the conversion
+ * happens here.
+ *
+ * `decodeAudioData` resamples to the context's rate, which is why the context
+ * is created at 16 kHz: that is Whisper's own rate, and it makes the upload a
+ * third of what 48 kHz would cost (32 KB per second of speech).
+ */
+
+export const WHISPER_SAMPLE_RATE = 16_000;
+
+/** Average the channels; Whisper takes mono and a stereo mic gains it nothing. */
+export function mixToMono(channels: Float32Array[]): Float32Array {
+  if (channels.length === 0) return new Float32Array(0);
+  if (channels.length === 1) return channels[0]!;
+  const length = channels[0]!.length;
+  const out = new Float32Array(length);
+  for (let i = 0; i < length; i++) {
+    let sum = 0;
+    for (const channel of channels) sum += channel[i] ?? 0;
+    out[i] = sum / channels.length;
+  }
+  return out;
+}
+
+/** 16-bit PCM WAV: a 44-byte header and the samples, clamped to [-1, 1). */
+export function encodeWavPcm16(samples: Float32Array, sampleRate: number): Uint8Array {
+  const buffer = new ArrayBuffer(44 + samples.length * 2);
+  const view = new DataView(buffer);
+  const ascii = (offset: number, text: string) => {
+    for (let i = 0; i < text.length; i++) view.setUint8(offset + i, text.charCodeAt(i));
+  };
+
+  ascii(0, "RIFF");
+  view.setUint32(4, 36 + samples.length * 2, true);
+  ascii(8, "WAVE");
+  ascii(12, "fmt ");
+  view.setUint32(16, 16, true); // PCM header size
+  view.setUint16(20, 1, true); // format: PCM
+  view.setUint16(22, 1, true); // channels: mono
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true); // byte rate
+  view.setUint16(32, 2, true); // block align
+  view.setUint16(34, 16, true); // bits per sample
+  ascii(36, "data");
+  view.setUint32(40, samples.length * 2, true);
+
+  for (let i = 0; i < samples.length; i++) {
+    const clamped = Math.max(-1, Math.min(1, samples[i]!));
+    view.setInt16(44 + i * 2, clamped < 0 ? clamped * 0x8000 : clamped * 0x7fff, true);
+  }
+  return new Uint8Array(buffer);
+}
+
+/** Decode a recording and re-encode it as a 16 kHz mono WAV. */
+export async function recordingToWav(blob: Blob): Promise<Uint8Array> {
+  const ctx = new OfflineAudioContext(1, 1, WHISPER_SAMPLE_RATE);
+  const decoded = await ctx.decodeAudioData(await blob.arrayBuffer());
+  const channels: Float32Array[] = [];
+  for (let i = 0; i < decoded.numberOfChannels; i++) channels.push(decoded.getChannelData(i));
+  // Header takes the buffer's own rate: a browser that declines to resample
+  // still produces a correct file, and whisper.cpp resamples it on its side.
+  return encodeWavPcm16(mixToMono(channels), decoded.sampleRate);
+}