Church Translate, as it runs at the campuses

Live sermon translation into 100+ languages, running entirely on one Mac per
campus: audio in, voice detection, Whisper on the GPU, NLLB-200 in its own
process, and a built-in web server the congregation reads from on their
phones. No audio leaves the building.

This is the source only. What used to sit beside it — 14 GB of speech and
translation models, 8 GB of voice bundles, 6 GB of natural voices, the Electron
caches, and the app data holding the operator PIN and every service transcript
— is machine state and downloaded assets, and stays in the NAS backup where it
belongs. The vendored node, cloudflared and Windows ffmpeg binaries are out too
(533 MB, re-fetched for packaging); the browser-side runtime beside them is
kept, so a checkout still serves the congregation page.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app/capture-worklet.js

@@ -0,0 +1,121 @@
+/*
+ * capture-worklet.js — pulls audio off the graph in fixed frames.
+ *
+ * Runs on the audio thread, so it does the least possible work: pick the
+ * channels that carry a microphone, average them, fill a frame, hand it over.
+ * All judgement about what is speech happens on the main thread where it
+ * cannot cause a dropout.
+ */
+
+/* An empty pick means "mix everything", which is right for a two-channel
+   console feed. A specific set is right for Dante or SoundGrid, where the
+   device presents 64 channels and the voice is on one or two of them — mixing
+   those would bury the speaker under 62 silent channels and make a perfectly
+   good feed look like silence. */
+function normalize(list) {
+  if (!Array.isArray(list)) return null;
+  const out = [];
+  for (const v of list) {
+    const n = Number(v);
+    if (Number.isInteger(n) && n >= 0 && out.indexOf(n) === -1) out.push(n);
+  }
+  return out.length ? out.sort((a, b) => a - b) : null;
+}
+
+/* Per-channel levels, posted about ten times a second. They are what makes a
+   64-channel device usable at all: without them, choosing the right channel is
+   guesswork against a list of identical names, and the only feedback is
+   whether the whole app appears broken. With them you watch for the one that
+   moves when someone talks. */
+const LEVEL_MS = 100;
+
+class CaptureProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const opts = (options && options.processorOptions) || {};
+    this._buf = new Float32Array(opts.frameSize || 1024);
+    this._n = 0;
+    this._pick = normalize(opts.channels);
+    this._reported = -1;
+
+    this._sumSq = null;      // per-channel accumulator for the level meters
+    this._sumN = 0;
+    this._lastLevel = 0;
+
+    /* Changing channel used to mean tearing the capture graph down and
+       building it again, which is not something to do mid-service. A message
+       is, so the picker now works while translation is running. */
+    this.port.onmessage = (e) => {
+      const d = e.data;
+      if (d && d.t === 'channels') this._pick = normalize(d.channels);
+    };
+  }
+
+  process(inputs) {
+    const input = inputs[0];
+    if (!input || input.length === 0) return true;
+
+    const chans = input.length;
+    const len = input[0].length;
+
+    /* Tell the main thread how many channels actually arrived, once. */
+    if (this._reported !== chans) {
+      this._reported = chans;
+      this._sumSq = new Float32Array(chans);
+      this._sumN = 0;
+      this.port.postMessage({ channels: chans });
+    }
+
+    /*
+     * Resolve the pick ONCE per render quantum, not once per sample. A channel
+     * index that no longer exists (the device changed underneath us) falls back
+     * to mixing rather than reading past the end of the array.
+     */
+    let picks = null;
+    if (this._pick) {
+      picks = [];
+      for (let k = 0; k < this._pick.length; k++) {
+        if (this._pick[k] < chans) picks.push(this._pick[k]);
+      }
+      if (!picks.length) picks = null;
+    }
+    const np = picks ? picks.length : chans;
+
+    for (let i = 0; i < len; i++) {
+      let sum = 0;
+      if (picks) for (let k = 0; k < np; k++) sum += input[picks[k]][i];
+      else       for (let c = 0; c < chans; c++) sum += input[c][i];
+      this._buf[this._n++] = sum / np;
+
+      if (this._n === this._buf.length) {
+        this.port.postMessage(this._buf.slice(0));
+        this._n = 0;
+      }
+    }
+
+    /* Levels for EVERY channel, including the ones not selected — the whole
+       point is to find the one that is moving. */
+    if (this._sumSq && this._sumSq.length === chans) {
+      for (let c = 0; c < chans; c++) {
+        const ch = input[c];
+        let s = 0;
+        for (let i = 0; i < len; i++) s += ch[i] * ch[i];
+        this._sumSq[c] += s;
+      }
+      this._sumN += len;
+
+      const now = currentTime * 1000;
+      if (now - this._lastLevel >= LEVEL_MS && this._sumN > 0) {
+        this._lastLevel = now;
+        const rms = new Float32Array(chans);
+        for (let c = 0; c < chans; c++) rms[c] = Math.sqrt(this._sumSq[c] / this._sumN);
+        this.port.postMessage({ levels: rms });
+        this._sumSq.fill(0);
+        this._sumN = 0;
+      }
+    }
+    return true;
+  }
+}
+
+registerProcessor('capture', CaptureProcessor);