kale-tts-1 / app.js
NERDDISCO's picture
Key letters off by default for new visitors; saved choices stay
15b2622
Raw History Blame Contribute Delete
32.3 kB
// kale-tts-1 space: type -> speech in the browser. nano (default) or tiny, onnxruntime-web 1.31.1 through the kale-tts JS API.
// WebGPU first on desktops (nano's float32 graph); the CPU / wasm (int8) on phones (WebGPU ran an iPhone out of memory in our phone
// tests), and where WebGPU is missing, fails, or crashed before (gpuTrial.js). A failed WebGPU load reloads the page on the CPU, so
// only one runtime is ever in memory. A loaded model stays loaded when you switch to the other one (desktops; phones keep one), and
// its graph stays in the browser's cache, so switching back or reloading doesn't download it again. Everything runs in this tab.
import { Listener, drawHeroLine, onDemandLoop, reducedMotion } from "./visual.js";
import { Waterfall } from "./waterfall.js";
import { gpuTrial, webGpuWorks } from "./gpuTrial.js";
const SR = 24000;
// graph per backend; sha256 per graph file: the key of its copy in the browser's cache (ttsWorker.js), so a new build is downloaded once
const MODELS = {
"kale-tts-1-nano": { params: "7.5M", size: "14.8 MB", graph: { webgpu: "fp32", wasm: "int8" }, shas: {
"model.onnx": "4d5269974de4fba7a66f947608a9a5381b4e39c1a8a6073df6001ab7e7f76288",
"model.fp32.onnx": "34d408a127f35f732a6860db5b1f7e8e1baac43ee3e32874f2007b5c6360e73a" } },
"kale-tts-1-tiny": { params: "45.7M", size: "79.9 MB", graph: { webgpu: "fp32", wasm: "int8" }, shas: {
"model.onnx": "8f255ef6f2b22c130cce15bdf92c5d420a821b2e5e39dbdef34064d52d6dc495",
"model.fp32.onnx": "885675190d58a5f28f096f4698526fa2a2f2378d9d1897b6b0721596f585f64f" } },
};
// the 10 public voices by id: name, what they are, colour (women, then men)
const NAMES = {
s057b: { name: "Kenzie", about: "esports hype woman", c: "#34d399" },
f06: { name: "Simone", about: "deep and confident woman", c: "#fb923c" },
d03: { name: "Amy", about: "british woman, crisp news-style", c: "#eab308" },
w165: { name: "Frankie", about: "hard-boiled detective's partner", c: "#ec4899" },
w602: { name: "Darlene", about: "rough low-voiced old trucker woman", c: "#a855f7" },
m3: { name: "Owen", about: "bright young host", c: "#3b82f6" },
t071: { name: "Toby", about: "mischievous prankster", c: "#22d3ee" },
d13: { name: "Jack", about: "british man, crisp news-style", c: "#6366f1" },
x328: { name: "Earl", about: "African American jazz granddad", c: "#8b5cf6" },
h013f: { name: "Magnus", about: "deep dramatic trailer narrator", c: "#db2777" },
};
const PALETTE = ["#34d399", "#f472b6", "#22d3ee", "#facc15", "#a3e635", "#f87171"]; // voices of older builds, not in NAMES
const $ = (s, r = document) => r.querySelector(s), $$ = (s, r = document) => [...r.querySelectorAll(s)];
const isPhone = /Android|iPhone|iPad|iPod|Mobile/i.test(navigator.userAgent) || (navigator.maxTouchPoints > 1 && /Macintosh/.test(navigator.userAgent));
const toast = (m) => { const t = $("#toast"); t.textContent = m; t.classList.add("on"); clearTimeout(t._h); t._h = setTimeout(() => t.classList.remove("on"), 3200); };
// ------------------------------------------------------------------------------------------ audio out
class Player {
constructor() { this.ctx = null; this.src = []; this.segs = []; this.next = 0; this.onend = null; }
async ensure() {
if (!this.ctx) {
this.ctx = new AudioContext({ sampleRate: SR }); this.out = this.ctx.createGain(); this.an = this.ctx.createAnalyser();
this.an.fftSize = 2048; this.an.smoothingTimeConstant = 0.6; this.out.connect(this.an); this.an.connect(this.ctx.destination); L = new Listener(this.an);
}
if (this.ctx.state !== "running") await this.ctx.resume();
}
reset() { for (const s of this.src) { try { s.stop(); } catch {} } this.src = []; this.segs = []; this.next = 0; }
push(audio, meta, gap = 0) {
const b = this.ctx.createBuffer(1, audio.length, SR); b.copyToChannel(audio, 0); const s = this.ctx.createBufferSource(); s.buffer = b; s.connect(this.out);
const at = Math.max(this.ctx.currentTime + 0.04, this.next + gap); s.start(at); this.next = at + b.duration; this.src.push(s); this.segs.push({ start: at, end: this.next, meta }); loop.kick();
s.onended = () => { const i = this.src.indexOf(s); if (i < 0) return; this.src.splice(i, 1); if (!this.src.length) this.onend?.(); };
}
get now() { return this.ctx ? this.ctx.currentTime : 0; }
get playing() { return this.src.length > 0; }
}
const player = new Player(); let L = null;
window.kaleDemo = { player, get level() { return L ? L.level : 0; } }; // for tests and recordings
// ------------------------------------------------------------------------------------------ where it runs
const gpu = gpuTrial("kale-tts-1", () => toast("WebGPU stopped this tab last time, so this device runs on the CPU now."));
let hasGpu = false;
const q = new URLSearchParams(location.search); // ?model= ?backend= (tests, and the CPU reload), ?gpufail, ?embed
const preferred = () => (!isPhone && hasGpu && gpu.allowed() && !q.has("gpufail") ? "webgpu" : "wasm");
/** start over on the CPU in a fresh page: what a WebGPU load left behind (its runtime, GPU memory) goes with the old one */
function reloadOn(backend, extra = {}) {
const u = new URL(location.href); u.searchParams.set("backend", backend); u.searchParams.delete("gpufail");
for (const [k, v] of Object.entries(extra)) u.searchParams.set(k, v);
gpu.passed(); location.replace(u); return new Promise(() => {});
}
const beName = (b) => (b === "webgpu" ? "WebGPU" : "CPU");
/** the status, for screen readers only: loading, ready, speaking or what went wrong */
function live(said, busy = false) {
$("#status").textContent = said; // read by screen readers only; loading shows on the model card, errors in a toast
$("#retry").hidden = !(M?.b === "wasm" && hasGpu && gpu.benched() && !busy);
}
// the stats under the model cards: the backend in use, and the first sound and speed of the last sentence played here
const TYPICAL = { "kale-tts-1-nano": [50, 100], "kale-tts-1-tiny": [60, 50] };
// estimates lead with "≈"
const ms = (v, est) => `${est ? "≈" : ""}${Math.round(v)} ms`, x = (v, est) => `${est ? "≈" : ""}${Math.round(v)}×`;
const typical = (name) => { const [f, r] = TYPICAL[name] ?? [50, 100]; return { first: ms(f, true), rt: x(r, true), typical: true }; };
function metrics({ be, first, rt, typical } = {}) {
if (be !== undefined) $("#m-be").textContent = be;
if (first !== undefined) $("#m-first").textContent = first;
if (rt !== undefined) $("#m-rt").textContent = rt;
$(".metrics").classList.toggle("typical", !!typical);
if (typical) $(".metrics").title = "typical: an estimate until you press play"; else $(".metrics").removeAttribute("title");
}
/** the status once a model is ready (for screen readers): ready, or the crash note if WebGPU is benched */
const idle = () => {
const benched = M.b === "wasm" && hasGpu && gpu.benched();
const said = heardSaid; heardSaid = null;
live(benched ? "ready, on the CPU: WebGPU is off here after a crash" : said ?? "ready");
};
const liveReady = () => {
idle();
$(".metrics").classList.remove("loading");
metrics({ be: beName(M.b), ...typical(M.name) });
};
// ------------------------------------------------------------------------------------------ the model (one in use, others kept)
let M = null, loading = null, booted = false; // booted: the first use() has started
// loaded models by name + backend: switching back to one is instant (no download, no new session). Phones keep only the one in use
// (memory); its graph is still in the browser's cache there, so loading it again doesn't download it.
const kept = new Map(), keyOf = (name, b) => `${name}|${b}`;
/** the model in its own worker (ttsWorker.js), behind the same small surface the page used before: voices, backend, stream() */
function workerTTS(name, b, opts) {
const w = new Worker(new URL("./ttsWorker.js", import.meta.url), { type: "module" });
let seq = 0, loaded = null; const on = new Map();
w.onmessage = ({ data: m }) => on.get(m.id)?.(m);
w.onerror = (e) => { e.preventDefault?.(); for (const f of on.values()) f({ type: "error", message: e.message || "the model's worker failed" });
if (loaded && kept.get(keyOf(name, b))?.tts === loaded) kept.delete(keyOf(name, b));
if (b === "webgpu" && loaded && M?.tts === loaded) reloadOn("wasm", { model: name, gpufail: "1" }); };
const call = (msg, handler) => { const id = ++seq; on.set(id, handler); w.postMessage({ ...msg, id }); return id; };
return new Promise((resolve, reject) => call({ type: "load", name, b, shas: MODELS[name].shas, ...opts }, (m) => {
if (m.type === "status") cardState(name, m.text);
else if (m.type === "progress") progress(name, m.got, m.total);
else if (m.type === "error") { w.terminate(); reject(new Error(m.message)); }
else if (m.type === "loaded") resolve(loaded = {
voices: m.voices, backend: { graph: m.graph },
session: { release: async () => w.terminate() },
async *stream(text, { voice }) {
const q = []; let wake = null, done = false, err = null;
const id = call({ type: "stream", text, voice }, (x) => {
if (x.type === "chunk") q.push(x); else { done = true; if (x.type === "error") err = new Error(x.message); }
wake?.();
});
try {
for (;;) { if (q.length) { yield q.shift(); continue; } if (done) break; await new Promise((r) => (wake = r)); wake = null; }
if (err) throw err;
} finally { on.delete(id); if (!done) w.postMessage({ type: "cancel", id }); }
},
});
}));
}
async function openModel(name, b) {
const tts = await workerTTS(name, b, { graph: MODELS[name].graph[b],
threads: self.crossOriginIsolated ? Math.min(4, navigator.hardwareConcurrency || 4) : 1,
sessionOptions: b === "wasm" && isPhone ? { graphOptimizationLevel: "disabled" } : {} });
return { tts, name, b };
}
async function use(name, b) {
if (!MODELS[name].graph[b]) b = "wasm";
if (M && M.name === name && M.b === b) return;
gen++; busy = false; player.reset(); setInert(true); markModel(name);
$$(".mcard").forEach((x) => x.setAttribute("aria-disabled", String(x.dataset.m !== name)));
const old = M; M = null; goState(); gpu.passed();
if (old && isPhone) { kept.delete(keyOf(old.name, old.b)); try { await old.tts.session.release?.(); } catch {} } // phones: one model in memory
const have = kept.get(keyOf(name, b));
if (have) { // loaded before: use it again as it is
M = have; if (M.b === "webgpu") gpu.begin(); else gpu.passed();
$$(".mcard").forEach((x) => x.removeAttribute("aria-disabled"));
$("#loadbar").className = "loadbar off"; cardState(name, null); liveReady();
buildKeys(M.tts.voices); setInert(false); goState(); return;
}
said50 = false; cardState(name, "starting…", { p: 0 });
$("#loadbar").className = "loadbar wait"; live(`loading ${name}${b === "webgpu" ? " on WebGPU" : ""}…`, true);
$(".metrics").classList.add("loading"); metrics({ be: beName(b), ...typical(name) }); // while loading: the typical values
if (b === "webgpu") gpu.begin();
// a GPU that hangs (after a crash, a lost device) must not leave the page loading forever: give up and use the CPU
const hung = new Promise((_, no) => setTimeout(() => no(new Error("WebGPU didn't answer")), b === "webgpu" ? 45000 : 180000));
try { M = await (loading = Promise.race([openModel(name, b), hung])); }
catch (e) {
console.warn(e); gpu.passed();
if (b === "webgpu") return reloadOn("wasm", { model: name, gpufail: "1" });
$("#loadbar").className = "loadbar off"; $(".metrics").classList.remove("loading"); cardState(name, "couldn't load · retry", { error: true });
live("couldn't load the model · press its card to try again"); toast("Couldn't load the model. Press its card to try again."); return;
}
finally { loading = null; $$(".mcard").forEach((x) => x.removeAttribute("aria-disabled")); }
kept.set(keyOf(name, b), M);
if (M.b === "wasm") gpu.passed(); // on WebGPU the mark stays for as long as the model runs there (see render)
$("#loadbar").className = "loadbar off"; cardState(name, null); liveReady();
buildKeys(M.tts.voices); setInert(false); goState();
}
/** the card of the model being loaded shows where it is: a thin bar for the download and a line of text (in place of its traits) */
function cardState(name, text, { p = null, error = false } = {}) {
const c = $(`.mcard[data-m="${name}"]`); if (!c) return;
const bar = $("#mprogress"); bar.hidden = text == null || error || p == null; bar.setAttribute("aria-label", `Downloading ${name}`);
if (p != null) bar.setAttribute("aria-valuenow", String(Math.round(p * 100)));
c.classList.toggle("busy", text != null); c.classList.toggle("failed", error);
$(".mstate", c).textContent = text ?? "";
if (p != null) c.style.setProperty("--p", String(p)); else if (text == null) c.style.removeProperty("--p");
}
let said50 = false; // the status (for screen readers) says it at the start, at half way and when ready, not every percent
function progress(name, got, total) {
const p = total ? Math.min(1, got / total) : null;
// a percentage only: sizes belong to the cards' CPU / GPU facts; a second MB figure next to them read as one of them
cardState(name, p != null ? `downloading ${Math.round(p * 100)}%` : "downloading…", { p: p ?? 0 });
if (p >= 0.5 && !said50) { said50 = true; live(`downloading ${name} · 50%`, true); }
}
function markModel(name) {
$("#mtitle").textContent = name; document.title = `${name} · speech in your browser`;
$$(".mcard").forEach((x) => { x.setAttribute("aria-checked", String(x.dataset.m === name)); x.tabIndex = x.dataset.m === name ? 0 : -1; });
fx?.setMode(name.endsWith("tiny") ? 1 : 0); placeHalo(); loop.kick(); // nano: the waterfall; tiny: mountains rising up the page
}
// ------------------------------------------------------------------------------------------ state + ui
let voice = null, keys = [], gen = 0, busy = false;
// the terrain and its waterfall (one shader); without WebGL2 a plain 2D line in the stage
let fx = null; try { fx = new Waterfall($("#fx")); if (!fx.ok) fx = null; } catch (e) { console.warn(e); fx = null; }
document.documentElement.classList.toggle("nofx", !fx);
const look = {}; const colorOf = (id) => look[id]?.c ?? "#34d399";
function setColor(id) { const c = colorOf(id); document.documentElement.style.setProperty("--vc", c); fx?.setColor(c); }
/** the voice keys. Drawn straight away from the known ten (no keys popping in later); inert until a model is loaded. Redrawn
* only if a loaded model has a different set of voices. */
const STATIC_VOICES = Object.keys(NAMES).map((id, order) => ({ id, name: NAMES[id].name, order }));
let builtFor = "";
function buildKeys(list = STATIC_VOICES) {
const vs = [...list].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
const ids = vs.map((v) => v.id).join(",");
if (ids === builtFor) return;
builtFor = ids;
vs.forEach((v, i) => { look[v.id] = NAMES[v.id] ?? { name: v.name.split("(")[0].trim(), about: (v.name.match(/\(([^)]*)\)/)?.[1] ?? ""), c: PALETTE[i % PALETTE.length] }; });
const box = $("#keys");
box.innerHTML = vs.map((v) => { const l = look[v.id];
return `<button class="key" data-v="${v.id}" style="--c:${l.c}" aria-label="${l.name}, ${l.about}" title="${l.about}"><kbd></kbd><b>${l.name}</b><small class="own" id="own-${v.id}"></small></button>`; }).join("");
keys = $$(".key").map((el) => ({ el, id: el.dataset.v }));
keys.forEach((k) => (k.el.onclick = () => speak(k.id)));
labelKeys(); showLines();
if (!vs.some((v) => v.id === voice)) voice = vs[0].id; select(voice);
}
/** the picked voice: coloured, and current for screen readers (keys replay, they don't toggle) */
const markSel = (id) => keys.forEach((k) => { k.el.classList.toggle("sel", k.id === id); if (k.id === id) k.el.setAttribute("aria-current", "true"); else k.el.removeAttribute("aria-current"); });
function select(id) { voice = id; markSel(id); setColor(id); goState(); loop.redraw(); }
/** before a model is ready the keys are there but can't be played */
function setInert(on) { $("#keys").classList.toggle("inert", on); keys.forEach((k) => (on ? k.el.setAttribute("aria-disabled", "true") : k.el.removeAttribute("aria-disabled"))); }
// ------------------------------------------------------------------------------------------ one line per voice (the a-line-per-voice Off | On picker)
// Off (the default): every voice speaks the text in the composer. On: every voice has its own line, shown on its key; picking a
// voice puts its line in the composer, and what you type there becomes that voice's line. Play the keys like an instrument.
// every voice starts without a line of its own and speaks the shared sentence until you type one (no examples)
const own = (() => { try { localStorage.removeItem("kale-tts-1:lines"); return JSON.parse(localStorage.getItem("kale-tts-1:voice-lines") || "{}"); } catch { return {}; } })();
let perKey = (() => { try { return localStorage.getItem("kale-tts-1:per-key") === "1"; } catch { return false; } })();
let shared = $("#text").value; // the sentence every voice speaks (and the fallback in the lines mode)
const textFor = (id) => (perKey ? own[id]?.trim() || shared : $("#text").value).trim();
/** the composer shows what you'd edit: in the lines mode the picked voice's own line (empty if it has none), else the shared one */
function fillComposer(id = voice) {
const t = $("#text");
if (perKey) { t.value = own[id] ?? ""; t.placeholder = `Write ${look[id]?.name ?? "this voice"}'s line, or leave it empty to use the shared text.`; }
else { t.value = shared; t.placeholder = "Type something to say"; }
}
function showLines() {
syncSegs(); $("#keys").classList.toggle("lines-on", perKey);
keys.forEach((k) => { $(".own", k.el).textContent = own[k.id]?.trim() ?? "";
if (perKey) k.el.setAttribute("aria-describedby", `own-${k.id}`); else k.el.removeAttribute("aria-describedby"); });
}
function setPerKey(on) {
perKey = on; try { localStorage.setItem("kale-tts-1:per-key", on ? "1" : "0"); } catch {}
fillComposer(); showLines(); goState();
}
/** the typed text in one voice: stream sentence by sentence into the speakers; the stats line under the cards shows how fast */
async function render(id, { gap = 0, my }) {
const text = textFor(id), t0 = performance.now(); let first = null, audioS = 0, chunks = 0;
for await (const ch of M.tts.stream(text, { voice: id })) {
if (my !== gen) return null; const now = performance.now();
if (first === null) first = now - t0;
player.push(ch.audio, { id }, chunks ? 0.12 : gap); if (!chunks++) goState(); audioS += ch.audio.length / SR;
metrics({ first: ms(first), rt: x(audioS / ((now - t0) / 1000)) });
}
if (first !== null) { const rt = audioS / ((performance.now() - t0) / 1000); // written (and said) once it has been heard
heardStats = { first: ms(first), rt: x(rt), said: `First sound ${Math.round(first)} ms, real time ${Math.round(rt)} times` }; }
return true;
}
/** the play button is a stop button while something is being made or heard */
let heardStats = null, heardSaid = null; // heardSaid: the measured stats, said once by the hidden status after playback
function goState() {
const on = busy || player.playing, b = $("#go"); b.classList.toggle("stop", on); b.setAttribute("aria-label", on ? "Stop" : "Play");
b.disabled = !on && !(M && textFor(voice)); // nothing to say (or no model yet): no Play that does nothing
b.title = !b.disabled ? "" : M ? "Type something to say" : "Loading the model…";
b.classList.toggle("playing", player.playing);
}
/** resolves when what was queued has been heard (or this run was replaced); one timer per wait, no polling loop */
const heard = (my) => new Promise((done) => { const check = () => (my !== gen || !player.playing ? done() : setTimeout(check, Math.max(30, (player.next - player.now) * 1000))); check(); });
async function speak(id = voice) {
if (!M) return; // keys are inert while a model loads: nothing changes, not even the composer
if (perKey && id !== voice) fillComposer(id); // the composer shows (and edits) the picked voice's line
if (!textFor(id)) { select(id); toast("Type something to say first."); return; }
const my = ++gen; let failed = false;
select(id); busy = true; goState(); // Stop shows in the same frame as the press
try {
await player.ensure(); player.reset(); heardStats = null;
live("speaking"); // for screen readers; on screen the Stop icon and its ring say it
// Stop stays up until the sentence has been heard to its end
if (await render(id, { my }) && my === gen) await heard(my);
} catch (e) {
console.warn(e); failed = true;
if (my === gen) { player.reset(); live("couldn't say that · press play to try again"); toast("Couldn't say that. Press play to try again."); }
} finally {
if (my === gen) { busy = false; if (!failed) idle(); } goState();
}
}
function stop() { gen++; busy = false; player.reset(); goState(); if (M) idle(); loop.redraw(); }
// ------------------------------------------------------------------------------------------ drawing (only while sound plays)
let shownId = null;
const frame = (dt, active) => {
const now = player.now; let seg = null; for (const s of player.segs) if (now >= s.start - 0.06 && now < s.end) seg = s;
const id = seg?.meta.id ?? null, moving = active && !reducedMotion.matches;
if (L && dt > 0) L.update(dt);
if (id && id !== shownId) { setColor(id); markSel(id); }
if (fx) fx.draw(L, dt, moving, player.playing); else drawHeroLine($("#line"), L, colorOf(id ?? voice), moving);
if (id !== shownId) { shownId = id; goState(); }
};
/** the waterfall always flows (flat when nobody speaks), but only while the page is shown and the water is on screen; phones at
* 30 fps; reduced motion: one still picture. Without the shader the 2D line draws only while sound plays. */
function flowing(frame) {
let raf = 0, last = 0, inView = true;
const slow = matchMedia("(max-width: 760px)").matches, want = () => !document.hidden && inView && !reducedMotion.matches;
const step = (now) => {
const dt = (now - last) / 1000;
if (slow && dt < 1 / 31) { raf = requestAnimationFrame(step); return; }
last = now; frame(Math.min(0.05, dt), true);
raf = want() ? requestAnimationFrame(step) : 0;
};
const start = () => { if (!raf && want()) { last = performance.now(); raf = requestAnimationFrame(step); } };
document.addEventListener("visibilitychange", start);
new IntersectionObserver(([e]) => { inView = e.isIntersecting; start(); }).observe($("#fx"));
reducedMotion.addEventListener?.("change", start);
return { kick: start, redraw() { if (!raf) frame(0, false); }, get running() { return !!raf; } };
}
const loop = fx ? flowing(frame) : onDemandLoop(frame, () => player.playing);
window.kaleDemo.loop = loop; window.kaleDemo.fx = fx;
// the end of the sound restores Play (an event, so it works with reduced motion, when no frames run) and announces the stats;
// a run that is still going keeps its Stop
player.onend = () => { if (heardStats) { metrics(heardStats); heardSaid = heardStats.said; heardStats = null; } if (!busy) goState(); loop.redraw(); };
let halo = null;
/** the haze the lines come out of: as wide as the lines (plus a margin), centred on the line where they start (nano: the water's
* edge; tiny: the live line in front), gliding along with the picture when the model changes */
function placeHalo() {
if (!halo) return; const tiny = $("#mtitle").textContent.endsWith("tiny"), el = $("#halo");
el.style.top = `${(tiny ? halo.rise : halo.fall) - halo.h / 2}px`;
}
/** the shader's canvas: from just above the edge to the end of the fall (the page grows to fit it if it is shorter), from left of
* the stage to the right edge; and the glow on the edge. The fall is a fixed length, so every screen ends it the same way. */
function placeFall() {
if (!fx) return;
// the whole page wide, from the top (tiny's mountains rise up to it) to the end of nano's fall; the picture is centred in the
// right column, its live line (where the water falls from) at the height of the model cards' middle
const cv = $("#fx"), mc = $(".models").getBoundingClientRect(), vw = document.documentElement.clientWidth;
const fall = vw <= 760 ? 560 : 820, edge = Math.round(mc.top + scrollY + mc.height / 2);
const height = Math.max(document.documentElement.scrollHeight, edge + fall + 60);
Object.assign(cv.style, { left: "0px", top: "0px", width: `${vw}px`, height: `${height}px` });
// the right column's middle (the whole width on a phone, where the column goes away)
const art = $(".art").getBoundingClientRect(), wide = art.width > 40, cx = wide ? art.left + art.width / 2 : vw / 2;
const w = wide ? Math.min(art.width * 1.15, 980) : Math.min(vw * 0.94, 980), h = vw <= 760 ? 220 : 300;
// the projection puts the edge at 0.848 of the box height: shift the box so the edge lands where we want it
const box = { x: cx - w / 2, y: edge - h * 0.848, w, h };
// tiny's mountains start lower: from the middle of the first row of voices (the women)
const row = $("#keys .key")?.getBoundingClientRect(), riseEdge = row ? Math.round(row.top + scrollY + row.height / 2) : edge;
fx.place({ ...box, streamX: cx, fall, rise: Math.max(120, riseEdge - 16), riseDy: riseEdge - edge });
halo = { fall: edge, rise: riseEdge, w: w * 0.83 * 1.18, h: h * 0.3 };
Object.assign($("#halo").style, { left: `${cx - halo.w / 2}px`, width: `${halo.w}px`, height: `${halo.h}px` }); placeHalo();
loop.redraw();
}
// ------------------------------------------------------------------------------------------ controls
const pickModel = (x) => { if (!booted || loading || M?.name === x.dataset.m) return; use(x.dataset.m, preferred()); };
$$(".mcard").forEach((x) => (x.onclick = () => pickModel(x)));
// one radio group: Tab reaches the checked card, the arrows move to (and pick) the other
$(".models").addEventListener("keydown", (e) => {
const step = { ArrowLeft: -1, ArrowUp: -1, ArrowRight: 1, ArrowDown: 1 }[e.key]; if (!step) return;
e.preventDefault(); if (!booted || loading) return; // focus never lands on a card that can't be picked
const cards = $$(".mcard"), x = cards[(cards.indexOf(e.target.closest(".mcard")) + step + cards.length) % cards.length];
x.focus(); pickModel(x);
});
$("#retry").onclick = () => { gpu.reset(); reloadOn("webgpu", M ? { model: M.name } : {}); };
$("#go").onclick = () => (busy || player.playing ? stop() : speak());
// ------------------------------------------------------------------------------------------ keyboard: the home row plays the voices
// Bound to physical keys (KeyboardEvent.code), so the same row works on every layout; only the printed letters differ. The labels
// come from the browser's layout map where it has one (Chrome, Edge), else from the layout picked with the keyboard button.
const ROW = ["KeyA", "KeyS", "KeyD", "KeyF", "KeyG", "KeyH", "KeyJ", "KeyK", "KeyL", "Semicolon"];
const LAYOUTS = {
QWERTY: "A S D F G H J K L ;", QWERTZ: "A S D F G H J K L Ö", AZERTY: "Q S D F G H J K L M", Dvorak: "A O E U I D H T N S",
};
const PICKS = ["auto", ...Object.keys(LAYOUTS)];
const stored = (() => { try { return localStorage.getItem("kale-tts-1:keys"); } catch { return null; } })();
let layout = PICKS.includes(stored) ? stored : "auto", detected = null;
// the key letters (and the home row that plays the voices) on or off: off for a new visitor; a saved choice stays, and so does an
// older saved layout pick (letters on, as they were then)
let lettersOn = (() => { try { const v = localStorage.getItem("kale-tts-1:key-letters"); return v === null ? PICKS.includes(stored) : v === "1"; } catch { return false; } })();
navigator.keyboard?.getLayoutMap?.().then((map) => { detected = ROW.map((c) => (map.get(c) ?? "").toUpperCase()); labelKeys(); }).catch(() => {});
function labelKeys() {
const marks = !lettersOn ? [] : layout === "auto" ? (detected?.every(Boolean) ? detected : LAYOUTS.QWERTY.split(" ")) : LAYOUTS[layout].split(" ");
keys.forEach((k, i) => { const kbd = $("kbd", k.el), m = marks[i]; kbd.textContent = m ?? ""; kbd.hidden = !m;
if (m) k.el.setAttribute("aria-keyshortcuts", m); else k.el.removeAttribute("aria-keyshortcuts"); });
syncSegs();
$("#layout").textContent = `layout: ${layout}`; $("#layout").classList.toggle("off", !lettersOn);
$("#layout").setAttribute("aria-label", `keyboard layout: ${layout === "auto" ? `auto${detected ? "" : " (QWERTY)"}` : layout}`);
}
function setLetters(on) {
lettersOn = on;
try { localStorage.setItem("kale-tts-1:key-letters", lettersOn ? "1" : "0"); } catch {}
labelKeys();
}
/** the Off | On pickers (radio groups) of the two options: checked, in the tab order, and the label brighter while On */
function syncSegs() {
for (const b of $$(".seg [role=radio]")) {
const on = b.dataset.seg === "lines" ? perKey : lettersOn, picked = on === (b.dataset.v === "1");
b.setAttribute("aria-checked", String(picked)); b.tabIndex = picked ? 0 : -1; b.closest(".opt").classList.toggle("on", on);
}
}
const pickSeg = (b) => (b.dataset.seg === "lines" ? setPerKey(b.dataset.v === "1") : setLetters(b.dataset.v === "1"));
$$(".seg [role=radio]").forEach((b) => (b.onclick = () => pickSeg(b)));
$$(".seg").forEach((g) => g.addEventListener("keydown", (e) => {
if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(e.key)) return;
e.preventDefault(); const other = $$("[role=radio]", g).find((b) => b !== e.target); other.focus(); pickSeg(other);
}));
$("#layout").onclick = () => {
layout = PICKS[(PICKS.indexOf(layout) + 1) % PICKS.length];
try { localStorage.setItem("kale-tts-1:keys", layout); } catch {}
labelKeys();
};
addEventListener("keydown", (e) => {
if (e.repeat || e.ctrlKey || e.metaKey || e.altKey) return;
// Enter with nothing focused plays the picked voice (a focused button or the composer handles its own Enter)
if (e.key === "Enter" && (e.target === document.body || e.target === document.documentElement)) { e.preventDefault(); speak(); return; }
if (!lettersOn || e.target.closest?.("textarea, input, select, [contenteditable]")) return;
const i = ROW.indexOf(e.code); if (i < 0 || !keys[i]) return;
e.preventDefault(); speak(keys[i].id);
});
// the text stays on its 24px line grid as it scrolls (Chrome's caret scroll can stop a few pixels short)
$("#text").addEventListener("input", () => {
requestAnimationFrame(() => { const t = $("#text"); t.scrollTop = Math.round(t.scrollTop / 24) * 24; });
if (perKey) { own[voice] = $("#text").value; try { localStorage.setItem("kale-tts-1:voice-lines", JSON.stringify(own)); } catch {} showLines(); }
else shared = $("#text").value;
goState();
});
$("#text").addEventListener("keydown", (e) => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); speak(); } });
/** the Kale wordmark as wide as the "brought to you by" line above it */
const sizeBrand = () => { const t = $(".brand span"), l = $(".brand svg"); if (t && l) l.style.width = `${t.getBoundingClientRect().width}px`; };
sizeBrand(); document.fonts?.ready.then(sizeBrand);
let rz; addEventListener("resize", () => { clearTimeout(rz); rz = setTimeout(placeFall, 120); });
reducedMotion.addEventListener?.("change", () => loop.redraw());
// ?embed (the canvas card's frame): no tall empty end. Not "inside a frame", since Hugging Face frames every Space.
if (q.has("embed")) document.documentElement.classList.add("framed");
buildKeys(); setInert(true);
setColor("s057b"); placeFall(); loop.kick();
await gpu.ready(); hasGpu = await Promise.race([webGpuWorks(), new Promise((r) => setTimeout(() => r(false), 4000))]);
if (q.has("gpufail")) toast("WebGPU didn't start here, so the CPU runs it.");
const qModel = MODELS[q.get("model")] ? q.get("model") : "kale-tts-1-nano", qB = q.get("backend");
booted = true;
await use(qModel, qB === "wasm" || (qB === "webgpu" && hasGpu) ? qB : preferred());
if (perKey) fillComposer(); // the lines mode was on last time
placeFall();
window.__ready = true;