@tablefolk/hear 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jason
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# @tablefolk/hear
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Speech to text in the browser, from either of two engines:
+
+- **Underdog Bark 3.0** (ai-ecoverse, CC-BY-4.0, a Parakeet-TDT 0.6B
+  fine-tune). It runs fp16 on WebGPU (1.3 GB once, ~0.4 s a sentence) or int8
+  on the processor (0.9 GB, ~1.2 s). 1.3% WER on LibriSpeech; the voice never
+  leaves the machine.
+- **the browser's SpeechRecognition** (Chrome: on this device when it has the
+  language pack).
+
+```js
+import { createListener } from '@tablefolk/hear';
+const ear = await createListener({ engine: 'auto', ask: async ({ gb }) => confirm(`Download ${gb} GB?`) });
+await ear.start();             // hold to talk...
+const text = await ear.stop(); // ...release: the words
+await ear.transcribe(pcm16k)   // Bark: your own 16 kHz Float32Array
+```
+
+`'auto'` picks the browser's recognition on a phone or tablet (lighter), Bark
+elsewhere. Helpers: `recorder()`, `toPcm16k(blob)`, `level(pcm)` (whether a
+clip is silent). Bark downloads from Hugging Face (Tablefolk's mirror on
+tablefolk.world).
+
+Part of [Tablefolk](https://github.com/runvnc/tablefolk) (`libs/`). MIT.

package/bark-worker.js

@@ -0,0 +1,125 @@
+/* asr/worker.js -- speech to text in the browser: Underdog Bark 3.0
+ * (ai-ecoverse/Underdog-Bark-3.0-ONNX, a Parakeet-TDT 0.6B fine-tune,
+ * CC-BY-4.0) on onnxruntime-web. The encoder (fp16, 1.2 GB) runs on WebGPU,
+ * the small decoder/joint network on WASM; mel.js is the feature frontend and
+ * the greedy TDT loop below is export/tdt.py of the model card.
+ *
+ * Messages in:  { type: 'load', urls: [base urls to try] }
+ *               { type: 'transcribe', id, audio: Float32Array (mono, 16 kHz) }
+ * Messages out: { type: 'progress', note, fraction } ... { type: 'ready' }
+ *               { type: 'text', id, text, ms } | { type: 'error', id?, message }
+ * Files are kept in the Cache API (tablefolk-asr-1), so a download happens once.
+ */
+import * as ort from 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.31.1/dist/ort.webgpu.min.mjs';
+import { logMel } from './mel.js';
+
+// fp16 (1.2 GB) on WebGPU where the card has shader-f16 (token-exact with the
+// reference on 19 of 20 clips); else int8 (0.84 GB) on WASM, which reads the
+// same words (the card measured it token-exact on fewer clips, but the text
+// matches on the ones checked). The int4 build is broken: never used.
+const VARIANTS = {
+  fp16: { enc: 'encoder_model_fp16.onnx', dec: 'decoder_joint_model_fp16.onnx', ep: 'webgpu', sizes: [0.001, 0.93, 0.06, 0.009] },
+  q4: { enc: 'encoder_model_q4f16.onnx', dec: 'decoder_joint_model_q4f16.onnx', ep: 'webgpu', sizes: [0.003, 0.862, 0.133, 0.002] },   // 0.52 GB (testing: ?asrvariant=q4)
+  q8: { enc: 'encoder_model_quantized.onnx', dec: 'decoder_joint_model_quantized.onnx', ep: 'wasm', sizes: [0.004, 0.92, 0.07, 0.006] },
+};
+async function pickVariant(force) {
+  if (force && VARIANTS[force]) return force;
+  try { const a = await navigator.gpu?.requestAdapter(); if (a?.features.has('shader-f16')) return 'fp16'; } catch {}
+  return 'q8';
+}
+const GEN = { blank: 8192, durations: [0, 1, 2, 3, 4], hidden: 640, layers: 2, maxSymbols: 10, eos: 3 };
+const CACHE = 'tablefolk-asr-1';
+ort.env.wasm.wasmPaths = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.31.1/dist/';
+ort.env.wasm.numThreads = self.crossOriginIsolated ? Math.min(4, navigator.hardwareConcurrency || 2) : 1;
+
+let enc = null, dec = null, pieces = null, loading = null;
+const say = m => postMessage(m);
+
+// R2 takes uploads up to 300 MiB through wrangler, so the big file is stored as
+// <name>.p000, .p001, ... and a <name>.parts.json ({ size, partSize, parts }),
+// fetched four at a time from the bucket's four hostnames (one connection each).
+const hostFor = (u, i) => u.replace('//geebr-models.mindroot.io', i % 4 ? `//geebr-models-${(i % 4) + 1}.mindroot.io` : '//geebr-models.mindroot.io');
+const pathFor = u => (/huggingface\.co/.test(u) ? 'onnx/' : '');
+async function readInto(resp, buf, at, onBytes) {
+  const reader = resp.body.getReader();
+  for (;;) { const { value, done } = await reader.read(); if (done) break; buf.set(value, at); at += value.length; onBytes(value.length); }
+}
+async function download(cache, name, urls, weight, base) {
+  const hit = await cache.match('/asr/' + name);
+  if (hit) return new Uint8Array(await hit.arrayBuffer());
+  let lastErr;
+  for (const u0 of urls) {
+    const u = u0.replace(/\/?$/, '/');
+    try {
+      let buf, got = 0, total = 0;
+      const tick = n => { got += n; say({ type: 'progress', note: `downloading ${name}`, fraction: base + weight * (total ? got / total : 0) }); };
+      const man = /huggingface\.co/.test(u) ? null : await fetch(u + name + '.parts.json').then(r => r.ok ? r.json() : null).catch(() => null);
+      if (man) {
+        total = man.size; buf = new Uint8Array(total);
+        let next = 0;
+        const lane = async () => { for (let i = next++; i < man.parts; i = next++) {
+          const r = await fetch(hostFor(u, i) + name + '.p' + String(i).padStart(3, '0')); if (!r.ok) throw new Error(`${name} part ${i}: HTTP ${r.status}`);
+          await readInto(r, buf, i * man.partSize, tick);
+        } };
+        await Promise.all([lane(), lane(), lane(), lane()]);
+      } else {
+        const r = await fetch(u + (name === 'tokenizer.json' ? '' : pathFor(u)) + name); if (!r.ok) throw new Error(`${name}: HTTP ${r.status}`);
+        total = +r.headers.get('content-length') || 0; buf = total ? new Uint8Array(total) : null;
+        if (buf) await readInto(r, buf, 0, tick);
+        else { buf = new Uint8Array(await r.arrayBuffer()); }
+      }
+      await cache.put('/asr/' + name, new Response(buf));
+      return buf;
+    } catch (e) { lastErr = e; }
+  }
+  throw lastErr || new Error('no model source');
+}
+
+async function load(urls, force) {
+  if (enc) return;
+  const V = VARIANTS[await pickVariant(force)], files = [V.enc, V.enc + '_data', V.dec, 'tokenizer.json'];
+  const cache = await caches.open(CACHE);
+  let base = 0; const got = {};
+  for (let i = 0; i < files.length; i++) { got[files[i]] = await download(cache, files[i], urls, V.sizes[i], base); base += V.sizes[i]; }
+  say({ type: 'progress', note: 'starting the speech model', fraction: 1 });
+  enc = await ort.InferenceSession.create(got[V.enc], { executionProviders: [V.ep], externalData: [{ path: V.enc + '_data', data: got[V.enc + '_data'] }] });
+  dec = await ort.InferenceSession.create(got[V.dec], { executionProviders: ['wasm'] });
+  const vocab = JSON.parse(new TextDecoder().decode(got['tokenizer.json'])).model.vocab;
+  pieces = []; for (const [p, id] of Object.entries(vocab)) pieces[id] = p;
+}
+
+const f32 = t => t.type === 'float16' ? Float32Array.from(t.data, halfToFloat) : t.data;
+function halfToFloat(h) { const s = (h & 0x8000) ? -1 : 1, e = (h >> 10) & 31, f = h & 1023; return e === 0 ? s * 5.960464477539063e-8 * f : e === 31 ? (f ? NaN : s * Infinity) : s * 2 ** (e - 15) * (1 + f / 1024); }
+
+async function transcribe(audio) {
+  const { features, T, valid } = logMel(audio);
+  const mask = new BigInt64Array(T); for (let t = 0; t < valid; t++) mask[t] = 1n;
+  const out = await enc.run({ input_features: new ort.Tensor('float32', features, [1, T, 128]), attention_mask: new ort.Tensor('int64', mask, [1, T]) });
+  const eo = out.encoder_outputs, len = Number(out.encoder_lengths.data[0]), E = f32(eo), Tp = eo.dims[1];
+  let h = new Float32Array(GEN.layers * GEN.hidden), c = new Float32Array(GEN.layers * GEN.hidden);
+  const toks = []; let last = GEN.blank, t = 0, steps = 0;
+  const maxSteps = GEN.maxSymbols * Tp - 1;
+  while (t < len && steps++ < maxSteps) {
+    const r = await dec.run({
+      encoder_outputs: new ort.Tensor('float32', E.slice(t * GEN.hidden, (t + 1) * GEN.hidden), [1, 1, GEN.hidden]),
+      input_ids: new ort.Tensor('int64', BigInt64Array.of(BigInt(last)), [1, 1]),
+      state_h: new ort.Tensor('float32', h, [GEN.layers, 1, GEN.hidden]), state_c: new ort.Tensor('float32', c, [GEN.layers, 1, GEN.hidden]),
+    });
+    const tl = f32(r.token_logits), dl = f32(r.duration_logits);
+    let tok = 0; for (let i = 1; i < tl.length; i++) if (tl[i] > tl[tok]) tok = i;
+    let di = 0; for (let i = 1; i < dl.length; i++) if (dl[i] > dl[di]) di = i;
+    let d = GEN.durations[di];
+    if (tok === GEN.blank) d = Math.max(d, 1); else { last = tok; h = Float32Array.from(f32(r.state_h_out)); c = Float32Array.from(f32(r.state_c_out)); toks.push(tok); }
+    t += d;
+    if (tok === GEN.eos) break;
+  }
+  return toks.filter(i => i !== GEN.blank && !(pieces[i].startsWith('<') && pieces[i].endsWith('>'))).map(i => pieces[i]).join('').replace(/▁/g, ' ').trim();
+}
+
+onmessage = async e => {
+  const m = e.data;
+  try {
+    if (m.type === 'load') { await (loading ||= load(m.urls, m.variant)); say({ type: 'ready' }); }
+    else if (m.type === 'transcribe') { await loading; const t0 = performance.now(); const text = await transcribe(m.audio); say({ type: 'text', id: m.id, text, ms: Math.round(performance.now() - t0) }); }
+  } catch (err) { loading = null; say({ type: 'error', id: m.id, message: String(err?.message || err) }); }
+};

package/index.js

@@ -0,0 +1,124 @@
+// @tablefolk/hear -- speech to text in the browser:
+//   browser  the browser's SpeechRecognition (Chrome: on this device when it
+//            has the language pack, which it may install; else its cloud)
+//   bark     Underdog Bark 3.0 (ai-ecoverse, CC-BY-4.0, a Parakeet-TDT 0.6B
+//            fine-tune) in a worker: fp16 on WebGPU (1.3 GB download once,
+//            ~0.4 s a sentence) or int8 on the processor (0.9 GB, ~1.2 s).
+//            Your voice never leaves the machine. 1.3% WER on LibriSpeech.
+//
+//   import { createListener } from '@tablefolk/hear';
+//   const ear = await createListener({ engine: 'auto', onStatus: s => console.log(s) });
+//   ear.engine, ear.why
+//   await ear.start();            // recording (hold-to-talk: start on press...)
+//   const text = await ear.stop() // ...stop on release: the words
+//   await ear.transcribe(pcm16k)  // bark: a Float32Array at 16 kHz you recorded yourself
+//
+// 'auto': a phone or tablet with SpeechRecognition uses it (lighter);
+// elsewhere Bark (ask: async ({ gb }) => true to allow its download, default
+// allowed), else the browser's. Bark's files come from Hugging Face, or
+// Tablefolk's mirror on tablefolk.world.
+import { createWorker, mirrorAllowed, sources, note } from '@tablefolk/models';
+import { detectHardware } from '@tablefolk/device';
+
+const BARK = { mirror: 'https://geebr-models.mindroot.io/underdog-bark-3.0/', hf: 'https://huggingface.co/ai-ecoverse/Underdog-Bark-3.0-ONNX/resolve/main/' };
+const SR = () => globalThis.SpeechRecognition || globalThis.webkitSpeechRecognition || null;
+
+export async function chooseEngine({ preferBrowserOnPhones = true } = {}) {
+  const hw = await detectHardware().catch(() => null);
+  if (preferBrowserOnPhones && SR() && hw && (hw.cls === 'phone' || hw.cls === 'tablet')) return { engine: 'browser', why: 'a phone or tablet: the browser\'s recognition is lighter' };
+  if (typeof Worker === 'function') return { engine: 'bark', why: 'Underdog Bark in this browser (private, accurate)' };
+  return SR() ? { engine: 'browser', why: 'the browser\'s recognition' } : { engine: null, why: 'no speech recognition here' };
+}
+// fp16 on the graphics card when it has shader-f16, else int8 on the processor
+export async function barkPlan({ cpu = false } = {}) {
+  let f16 = false; try { f16 = !!(await navigator.gpu?.requestAdapter())?.features.has('shader-f16'); } catch {}
+  return f16 && !cpu ? { variant: 'fp16', gb: 1.3, where: 'the graphics card' } : { variant: 'q8', gb: 0.9, where: 'the processor' };
+}
+
+export async function createListener({ engine = 'auto', onStatus = () => {}, ask = null, cpu = false, lang = null } = {}) {
+  let pick = engine === 'auto' ? await chooseEngine() : { engine, why: 'asked for' };
+  if (pick.engine === 'bark') {
+    const plan = await barkPlan({ cpu });
+    if (ask && !(await ask(plan))) pick = SR() ? { engine: 'browser', why: 'Bark\'s download declined: the browser\'s recognition' } : { engine: null, why: 'Bark\'s download declined' };
+  }
+  if (!pick.engine) throw new Error(pick.why);
+  note('hear', `${pick.engine}: ${pick.why}`);
+  return pick.engine === 'browser' ? browserListener(pick, lang) : barkListener(pick, { onStatus, cpu });
+}
+
+// ---- Bark
+async function barkListener(pick, { onStatus, cpu }) {
+  const plan = await barkPlan({ cpu });
+  const w = createWorker(new URL('./bark-worker.js', import.meta.url));
+  const wait = new Map(); let id = 0;
+  await new Promise((resolve, reject) => {
+    w.onmessage = e => {
+      const m = e.data;
+      if (m.type === 'progress') onStatus(`${m.note || 'loading'} ${Math.round(m.fraction * 100)}%`);
+      else if (m.type === 'ready') resolve();
+      else if (m.type === 'text') { wait.get(m.id)?.resolve(m.text); wait.delete(m.id); }
+      else if (m.type === 'error') { if (m.id != null) { wait.get(m.id)?.reject(new Error(m.message)); wait.delete(m.id); } else reject(new Error(m.message)); }
+    };
+    w.onerror = e => reject(new Error(e.message || 'speech worker failed'));
+    w.postMessage({ type: 'load', urls: sources(BARK, mirrorAllowed()), variant: plan.variant });
+  });
+  onStatus(`Underdog Bark ready on ${plan.where}`);
+  const transcribe = pcm => new Promise((resolve, reject) => { const n = ++id; wait.set(n, { resolve, reject }); const a = Float32Array.from(pcm); w.postMessage({ type: 'transcribe', id: n, audio: a }, [a.buffer]); });
+  const rec = recorder();
+  return { engine: 'bark', why: pick.why + ` (${plan.where})`, transcribe,
+    start: () => rec.start(),
+    async stop() { const blob = await rec.stop(); if (!blob) return ''; const pcm = await toPcm16k(blob); return level(pcm).voiced < .02 ? '' : transcribe(pcm); },
+    cancel: () => rec.stop(), unload() { rec.stop(); w.terminate(); } };
+}
+
+// ---- the browser's recognition
+function browserListener(pick, lang) {
+  const R = SR(); if (!R) throw new Error('no SpeechRecognition in this browser');
+  lang ||= navigator.language || 'en-US';
+  let recog = null, latest = '', ended = null;
+  return { engine: 'browser', why: pick.why,
+    async start() {
+      let local = false;
+      try { const o = { langs: [lang], processLocally: true }, a = await R.available?.(o); if (a === 'available') local = true; else if (a === 'downloadable' || a === 'downloading') local = !!(await R.install(o)); } catch {}
+      recog = new R(); recog.lang = lang; recog.interimResults = true; recog.continuous = true; if (local) recog.processLocally = true;
+      latest = ''; ended = new Promise(r => { recog.onend = () => r(latest); });
+      recog.onresult = e => { latest = [...e.results].map(x => x[0].transcript).join(' '); };
+      recog.start();
+      return { local };
+    },
+    async stop() { if (!recog) return ''; recog.stop(); const t = await ended; recog = null; return t.trim(); },
+    cancel() { recog?.abort(); recog = null; },
+    transcribe() { throw new Error('the browser\'s recognition listens itself: use start() and stop()'); },
+    unload() { recog?.abort(); } };
+}
+
+// ---- helpers: the microphone, 16 kHz mono, loudness
+export function recorder() {
+  let rec = null, chunks = [], stream = null;
+  return {
+    async start() {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true } });
+      chunks = []; rec = new MediaRecorder(stream); rec.ondataavailable = e => e.data.size && chunks.push(e.data); rec.start();
+    },
+    stop() {
+      if (!rec) return Promise.resolve(null);
+      return new Promise(res => { const r = rec; rec = null; r.onstop = () => { stream.getTracks().forEach(t => t.stop()); res(new Blob(chunks, { type: r.mimeType })); }; r.stop(); });
+    },
+  };
+}
+export async function toPcm16k(blob) {
+  const ctx = new AudioContext(), buf = await ctx.decodeAudioData(await blob.arrayBuffer()); ctx.close();
+  const rate = 16000, off = new OfflineAudioContext(1, Math.ceil(buf.duration * rate), rate);
+  const src = off.createBufferSource(); src.buffer = buf; src.connect(off.destination); src.start();
+  return (await off.startRendering()).getChannelData(0);
+}
+// peak, seconds, and the share of 20 ms frames louder than -40 dBFS (a silent
+// clip is better not transcribed: recognisers hear "Thank you" in silence)
+export function level(pcm) {
+  let peak = 0, voiced = 0, frames = 0;
+  for (let i = 0; i + 320 <= pcm.length; i += 320) {
+    let e = 0; for (let j = i; j < i + 320; j++) { const v = pcm[j]; e += v * v; if (v > peak) peak = v; else if (-v > peak) peak = -v; }
+    frames++; if (Math.sqrt(e / 320) > .01) voiced++;
+  }
+  return { peak, seconds: pcm.length / 16000, voiced: frames ? voiced / frames : 0 };
+}

package/mel.js

@@ -0,0 +1,75 @@
+/* asr/mel.js -- the log-mel frontend of Parakeet-TDT speech models (Underdog
+ * Bark 3.0), in plain JS: a port of export/tdt.py from
+ * ai-ecoverse/Underdog-Bark-3.0-ONNX (transformers' ParakeetFeatureExtractor).
+ * One utterance: mono 16 kHz Float32Array -> { features [T*128], T, valid }.
+ * ES module; runs in the worker and in Node (the test compares it with the
+ * model card's fixture).
+ */
+export const PP = { sr: 16000, nFft: 512, hop: 160, win: 400, mels: 128, preemph: 0.97, lead: 0.25, fmin: 0, fmax: 8000, guard: 5.960464477539063e-08, eps: 1e-5 };
+
+// librosa.filters.mel(norm='slaney', htk=False): [mels][nFft/2+1]
+export function melFilters(p = PP) {
+  const hz2mel = f => f < 1000 ? f / (200 / 3) : 15 + Math.log(f / 1000) / (Math.log(6.4) / 27);
+  const mel2hz = m => m < 15 ? m * (200 / 3) : 1000 * Math.exp((m - 15) * (Math.log(6.4) / 27));
+  const bins = p.nFft / 2 + 1, lo = hz2mel(p.fmin), hi = hz2mel(p.fmax);
+  const pts = Array.from({ length: p.mels + 2 }, (_, i) => mel2hz(lo + (hi - lo) * i / (p.mels + 1)));
+  const out = [];
+  for (let m = 0; m < p.mels; m++) {
+    const row = new Float32Array(bins), l = pts[m], c = pts[m + 1], r = pts[m + 2], en = 2 / (r - l);
+    for (let k = 0; k < bins; k++) {
+      const f = k * p.sr / p.nFft, w = Math.max(0, Math.min((f - l) / (c - l), (r - f) / (r - c)));
+      row[k] = w * en;
+    }
+    out.push(row);
+  }
+  return out;
+}
+
+// in-place radix-2 FFT of re/im (length a power of two)
+function fft(re, im) {
+  const n = re.length;
+  for (let i = 1, j = 0; i < n; i++) {
+    let bit = n >> 1; for (; j & bit; bit >>= 1) j ^= bit; j ^= bit;
+    if (i < j) { [re[i], re[j]] = [re[j], re[i]]; [im[i], im[j]] = [im[j], im[i]]; }
+  }
+  for (let len = 2; len <= n; len <<= 1) {
+    const ang = -2 * Math.PI / len, wr = Math.cos(ang), wi = Math.sin(ang);
+    for (let i = 0; i < n; i += len) {
+      let cr = 1, ci = 0;
+      for (let k = 0; k < len / 2; k++) {
+        const a = i + k, b = a + len / 2, tr = re[b] * cr - im[b] * ci, ti = re[b] * ci + im[b] * cr;
+        re[b] = re[a] - tr; im[b] = im[a] - ti; re[a] += tr; im[a] += ti;
+        const nr = cr * wr - ci * wi; ci = cr * wi + ci * wr; cr = nr;
+      }
+    }
+  }
+}
+
+let cached = null;
+export function logMel(wave, p = PP) {
+  const filters = cached ||= melFilters(p);
+  const lead = Math.round(p.lead * p.sr), L = wave.length + lead, x = new Float32Array(L);
+  x.set(wave, lead);
+  // pre-emphasis (first sample kept), then zero padding by nFft/2 each side (centre)
+  const pe = new Float32Array(L); pe[0] = x[0];
+  for (let i = 1; i < L; i++) pe[i] = x[i] - p.preemph * x[i - 1];
+  const half = p.nFft / 2, xp = new Float32Array(L + p.nFft); xp.set(pe, half);
+  const T = 1 + Math.floor(L / p.hop), valid = Math.floor(L / p.hop), bins = half + 1;
+  const w = new Float32Array(p.nFft), off = (p.nFft - p.win) / 2;
+  for (let i = 0; i < p.win; i++) w[off + i] = 0.5 - 0.5 * Math.cos(2 * Math.PI * i / (p.win - 1));
+  const out = new Float32Array(T * p.mels), re = new Float64Array(p.nFft), im = new Float64Array(p.nFft), power = new Float32Array(bins);
+  for (let t = 0; t < T; t++) {
+    for (let i = 0; i < p.nFft; i++) { re[i] = xp[t * p.hop + i] * w[i]; im[i] = 0; }
+    fft(re, im);
+    for (let k = 0; k < bins; k++) power[k] = re[k] * re[k] + im[k] * im[k];
+    for (let m = 0; m < p.mels; m++) { const f = filters[m]; let s = 0; for (let k = 0; k < bins; k++) s += power[k] * f[k]; out[t * p.mels + m] = Math.log(s + p.guard); }
+  }
+  // per-feature normalisation over the valid frames (unbiased), padding zeroed
+  for (let m = 0; m < p.mels; m++) {
+    let mean = 0; for (let t = 0; t < valid; t++) mean += out[t * p.mels + m]; mean /= valid;
+    let v = 0; for (let t = 0; t < valid; t++) { const d = out[t * p.mels + m] - mean; v += d * d; }
+    const std = Math.sqrt(v / (valid - 1));
+    for (let t = 0; t < T; t++) out[t * p.mels + m] = t < valid ? (out[t * p.mels + m] - mean) / (std + p.eps) : 0;
+  }
+  return { features: out, T, valid };
+}

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "@tablefolk/hear",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Speech to text in the browser: Underdog Bark 3.0 (Parakeet TDT, WebGPU or CPU) or the browser's SpeechRecognition, chosen for the device.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./*": "./*"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/runvnc/tablefolk.git",
+    "directory": "libs/hear"
+  },
+  "homepage": "https://github.com/runvnc/tablefolk/tree/main/libs/hear",
+  "keywords": [
+    "tablefolk",
+    "browser",
+    "asr",
+    "speech-recognition",
+    "stt",
+    "parakeet",
+    "webgpu"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@tablefolk/models": "^0.1.0",
+    "@tablefolk/device": "^0.1.0"
+  }
+}