Skip to content

armgit / Handy

Public Imported from GitHub
0

A free, open source, and extensible speech-to-text application that works completely offline.

fix: show model loading in the Live preview when the load is slow

CJ Pais417dc6ac26ac
diff --git a/src/overlay/RecordingOverlay.css b/src/overlay/RecordingOverlay.css
index eb400687..7088265d 100644
--- a/src/overlay/RecordingOverlay.css
+++ b/src/overlay/RecordingOverlay.css
@@ -271,6 +271,9 @@
.stext-cap .tentative {
color: inherit;
}
+.stext-cap .sloading {
+ color: var(--s-muted);
+}
.scaret {
display: inline-block;
width: 2px;
diff --git a/src/overlay/RecordingOverlay.tsx b/src/overlay/RecordingOverlay.tsx
index 3085c747..4deb7ee4 100644
--- a/src/overlay/RecordingOverlay.tsx
+++ b/src/overlay/RecordingOverlay.tsx
@@ -19,6 +19,12 @@ type OverlayState = "recording" | "streaming" | "transcribing" | "processing";
// every overlay form). Mic levels arrive as 16 FFT buckets; we take the first N.
const WAVE_BARS = 9;
+// Only call out a model load in the Live preview once it has run this long.
+// Warm loads finish in well under this (~0.2s on Apple Silicon, ~1.5s on a
+// Windows CPU backend), so the common case never flashes a loading notice while
+// the user is speaking; cold loads can take 40s+.
+const SLOW_MODEL_LOAD_MS = 2000;
+
const RecordingOverlay: React.FC = () => {
const { t } = useTranslation();
const [isVisible, setIsVisible] = useState(false);
@@ -27,10 +33,17 @@ const RecordingOverlay: React.FC = () => {
// Stay visually in an arming state until the backend processes the first
// actual microphone sample chunk.
const [captureReady, setCaptureReady] = useState(false);
- // Recording starts while the model loads in the background. If the user stops
- // before the load finishes, the wait is the load, not the transcription — say
- // so, otherwise a cold start looks like a hung "Transcribing..." spinner.
+ // Recording starts while the model loads in the background. Say so, otherwise
+ // a cold start looks like an empty Live preview that ignores speech, then a
+ // hung "Transcribing..." spinner. Once recording stops, any in-flight load is
+ // the wait, so the working label reflects it immediately; the Live notice
+ // waits for the load to be slow so fast loads don't flash it mid-speech.
const [modelLoading, setModelLoading] = useState(false);
+ const [modelLoadSlow, setModelLoadSlow] = useState(false);
+ const modelLoadTimerRef = useRef<ReturnType<typeof setTimeout>>();
+ // Latched per Live session: once the loading notice has opened the panel, keep
+ // it open after the load so it doesn't collapse and reopen when text arrives.
+ const [loadNoticeShown, setLoadNoticeShown] = useState(false);
const [levels, setLevels] = useState<number[]>(Array(WAVE_BARS).fill(0));
const [streamText, setStreamText] = useState<StreamTextEvent>({
committed: "",
@@ -89,6 +102,7 @@ const RecordingOverlay: React.FC = () => {
setPhase("listening");
setWorkKind("transcribing");
setElapsed(0);
+ setLoadNoticeShown(false);
setSession((s) => s + 1); // remount the card fresh for this session
}
setIsVisible(true);
@@ -126,12 +140,30 @@ const RecordingOverlay: React.FC = () => {
if (payload.kind) setWorkKind(payload.kind);
});
- // Every other model event (completed, failed, unloaded, selection
- // changed) means no load is in flight.
+ // The backend ends every `loading_started` with exactly one of completed
+ // or failed, so only those end a load. Other events (e.g. `unloaded` from
+ // the idle watcher) aren't ordered against an in-flight load and must not
+ // clear it.
const unlistenModel = await listen<ModelStateEvent>(
"model-state-changed",
(event) => {
- setModelLoading(event.payload.event_type === "loading_started");
+ const type = event.payload.event_type;
+ if (type === "loading_started") {
+ clearTimeout(modelLoadTimerRef.current);
+ setModelLoading(true);
+ setModelLoadSlow(false);
+ modelLoadTimerRef.current = setTimeout(
+ () => setModelLoadSlow(true),
+ SLOW_MODEL_LOAD_MS,
+ );
+ } else if (
+ type === "loading_completed" ||
+ type === "loading_failed"
+ ) {
+ clearTimeout(modelLoadTimerRef.current);
+ setModelLoading(false);
+ setModelLoadSlow(false);
+ }
},
);
@@ -143,6 +175,7 @@ const RecordingOverlay: React.FC = () => {
unlistenStream();
unlistenPhase();
unlistenModel();
+ clearTimeout(modelLoadTimerRef.current);
};
};
@@ -166,6 +199,12 @@ const RecordingOverlay: React.FC = () => {
if (pinnedRef.current) el.scrollTop = el.scrollHeight;
}, [streamText]);
+ // `session` re-runs this when a new Live session starts mid-load (e.g. a
+ // retry during a cold load), since the reset doesn't change the other deps.
+ useEffect(() => {
+ if (modelLoadSlow && state === "streaming") setLoadNoticeShown(true);
+ }, [modelLoadSlow, state, session]);
+
// Each fresh streaming session starts pinned to the bottom, fade cleared.
useEffect(() => {
pinnedRef.current = true;
@@ -251,11 +290,14 @@ const RecordingOverlay: React.FC = () => {
const hasText =
streamText.committed.length > 0 || streamText.tentative.length > 0;
const working = phase === "working";
+ // While listening, a slow model load opens the panel with a notice where the
+ // text would be, so speech that isn't transcribing yet doesn't look ignored.
+ const loadingNotice = modelLoadSlow && !working && !hasText;
// Keep the panel open whenever there's text — even while finalizing — so the
// transcript stays put under a working spinner instead of collapsing and
// squishing the text mid-stream. Only fall back to the small working pill
// when there was no text to preserve.
- const open = hasText;
+ const open = hasText || loadingNotice || (loadNoticeShown && !working);
const collapsed = working && !hasText;
return (
@@ -274,13 +316,18 @@ const RecordingOverlay: React.FC = () => {
onScroll={handleStreamScroll}
>
<p>
+ {loadingNotice && (
+ <span className="sloading">
+ {t("overlay.loadingModel")}
+ </span>
+ )}
<span className="committed">
{streamText.committed ? streamText.committed + " " : ""}
</span>
<span className="tentative">{streamText.tentative}</span>
{/* Drop the blinking caret once finalizing — it's no longer
capturing, and a static spinner conveys the work. */}
- {!working && <span className="scaret" />}
+ {!working && !loadingNotice && <span className="scaret" />}
</p>
</div>
</div>