Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

13.6 KB
Raw Blame
const test = require("node:test");
const assert = require("node:assert/strict");
const { EventEmitter } = require("node:events");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");

const WORKER_SOURCE = fs.readFileSync(path.resolve("src/workers/onnxWorker.js"), "utf8");
const CLIENT_SOURCE = fs.readFileSync(path.resolve("src/helpers/onnxWorkerClient.js"), "utf8");
const EMBEDDINGS_SOURCE = fs.readFileSync(path.resolve("src/helpers/localEmbeddings.js"), "utf8");
const SPEAKER_SOURCE = fs.readFileSync(path.resolve("src/helpers/speakerEmbeddings.js"), "utf8");
const SPEAKER_SAMPLES = new Float32Array(16000 * 2).fill(0.1);

function fakeOrt(events, nativeSession) {
  return {
    InferenceSession: {
      create: async (file) => {
        const name = path.basename(file) === "model.onnx" ? "text" : "speaker";
        events.push(`${name}.create`);
        return nativeSession(name);
      },
    },
    Tensor: class {},
  };
}

function loadEmbeddings(client) {
  const localContext = vm.createContext({
    module: { exports: {} },
    __dirname: path.resolve("src/helpers"),
    process: {},
    require(name) {
      if (name === "fs") return { existsSync: () => true };
      if (name === "./debugLogger") return { debug() {} };
      if (name === "./onnxWorkerClient") return client;
      return require(name);
    },
  });
  vm.runInContext(EMBEDDINGS_SOURCE, localContext);
  return localContext.module.exports;
}

function loadSpeakerEmbeddings(client, idleTimers) {
  const context = vm.createContext({
    module: { exports: {} },
    process: {},
    setTimeout(callback) {
      const timer = { callback, cleared: false, unref() {} };
      idleTimers.push(timer);
      return timer;
    },
    clearTimeout(timer) {
      if (timer) timer.cleared = true;
    },
    require(name) {
      if (name === "fs") return { existsSync: () => true };
      if (name === "./debugLogger") return { debug() {}, warn() {} };
      if (name === "./modelDirUtils") return { getModelsDirForService: () => "/models" };
      if (name === "./onnxWorkerClient") return client;
      return require(name);
    },
  });
  vm.runInContext(SPEAKER_SOURCE, context);
  return context.module.exports;
}

function createHarness() {
  const events = [];
  let releaseInference;
  let gateInference = false;
  const nativeSession = (name) => ({
    inputNames: ["input"],
    async run() {
      events.push(`${name}.run`);
      if (name === "text" && gateInference) {
        await new Promise((resolve) => {
          releaseInference = resolve;
        });
      }
      events.push(`${name}.done`);
      return { last_hidden_state: { data: new Float32Array(768).fill(1) } };
    },
    async release() {
      events.push(`${name}.release`);
    },
  });
  const workerContext = vm.createContext({
    require(name) {
      if (name === "fs") return { readFileSync: () => JSON.stringify({ model: { vocab: {} } }) };
      if (name === "onnxruntime-node")
        return {
          InferenceSession: {
            create: async (file) => nativeSession(file === "speaker" ? "speaker" : "text"),
          },
          Tensor: class {},
        };
      return require(name);
    },
    process: { env: {}, on() {}, parentPort: { once() {} } },
    setImmediate,
  });
  vm.runInContext(WORKER_SOURCE, workerContext);
  const dispatch = vm.runInContext("dispatch", workerContext);
  const client = {
    generation: 0,
    async request(method, payload) {
      events.push(method);
      const { reply } = await dispatch({ id: 1, method, payload });
      if (reply.error) throw new Error(reply.error.message);
      return reply.result;
    },
    async releaseIfIdle() {
      events.push("releaseIfIdle");
      return false;
    },
  };
  return {
    embeddings: loadEmbeddings(client),
    client,
    events,
    gateInference() {
      gateInference = true;
    },
    releaseInference() {
      gateInference = false;
      releaseInference();
    },
  };
}

async function nextTurn() {
  await new Promise((resolve) => setImmediate(resolve));
}

test("unloads the text session, preserves speaker inference, and reloads on next embedding", async () => {
  const { embeddings, client, events } = createHarness();
  await client.request("speaker.load", { modelPath: "speaker" });
  await embeddings.embedText("");
  await embeddings.unload();
  const { sessions } = await client.request("ping", {});
  assert.equal(sessions.text, false);
  assert.equal(sessions.speaker, true);
  await client.request("speaker.extract", { samplesBuffer: new Float32Array(400).buffer });
  assert.ok(events.includes("speaker.run"));
  assert.ok(!events.includes("speaker.release"));
  await embeddings.embedText("");
  assert.equal(events.filter((event) => event === "text.load").length, 2);
});

test("unload waits for inference and a racing embedding reloads after release", async () => {
  const harness = createHarness();
  harness.gateInference();
  const first = harness.embeddings.embedText("");
  await nextTurn();
  const unloading = harness.embeddings.unload();
  const second = harness.embeddings.embedText("");
  await nextTurn();
  assert.ok(!harness.events.includes("text.release"));
  harness.releaseInference();
  await Promise.all([first, unloading, second]);
  assert.deepEqual(
    harness.events.filter((event) => event.startsWith("text")),
    [
      "text.load",
      "text.embed",
      "text.run",
      "text.done",
      "text.unload",
      "text.release",
      "text.load",
      "text.embed",
      "text.run",
      "text.done",
    ]
  );
});

test("worker serializes text unload behind in-flight native inference", async () => {
  const harness = createHarness();
  await harness.client.request("text.load", { modelDir: "text" });
  harness.gateInference();
  const first = harness.client.request("text.embed", { text: "" });
  await nextTurn();
  const unload = harness.client.request("text.unload", {});
  await nextTurn();
  assert.ok(!harness.events.includes("text.release"));
  harness.releaseInference();
  await Promise.all([first, unload]);
  assert.ok(harness.events.indexOf("text.done") < harness.events.indexOf("text.release"));
});

test("reloads after the shared worker restarts", async () => {
  const { embeddings, client, events } = createHarness();
  await embeddings.embedText("");
  await client.request("text.unload", {});
  client.generation += 1;
  await embeddings.embedText("");
  assert.equal(events.filter((event) => event === "text.load").length, 2);
});

test("a failed load does not block unloading or the next load attempt", async () => {
  const { embeddings, client, events } = createHarness();
  const request = client.request.bind(client);
  let failLoad = true;
  client.request = async (method, payload) => {
    if (method === "text.load" && failLoad) {
      failLoad = false;
      throw new Error("model unavailable");
    }
    return request(method, payload);
  };
  await assert.rejects(embeddings.embedText(""), /model unavailable/);
  await embeddings.unload();
  const result = await embeddings.embedText("");
  assert.equal(result.length, 384);
  assert.equal(events.filter((event) => event === "text.run").length, 1);
});

test("unload waits for the complete embedding batch", async () => {
  const harness = createHarness();
  harness.gateInference();
  const batch = harness.embeddings.embedTexts(["", ""]);
  await nextTurn();
  const unload = harness.embeddings.unload();
  harness.releaseInference();
  assert.equal((await batch).length, 2);
  await unload;
  const finished = harness.events.lastIndexOf("text.done");
  assert.ok(finished < harness.events.indexOf("text.release"));
});

test("unload asks the worker client to release itself once the text session is gone", async () => {
  const { embeddings, events } = createHarness();
  await embeddings.embedText("");
  await embeddings.unload();
  assert.ok(events.indexOf("text.unload") < events.indexOf("releaseIfIdle"));
});

class FakePort extends EventEmitter {
  constructor() {
    super();
    this.peer = null;
    this.closed = false;
  }

  start() {}

  postMessage(data) {
    const { peer } = this;
    setImmediate(() => {
      if (!peer.closed) peer.emit("message", { data });
    });
  }

  close() {
    this.closed = true;
    this.peer.emit("close");
  }
}

// The real client driving the real worker source: each fork boots a fresh worker context.
function createIntegratedHarness({ failRelease = null } = {}) {
  const events = [];
  const workers = [];
  const idleTimers = [];
  const nativeSession = (name) => ({
    inputNames: ["input"],
    async run() {
      return { last_hidden_state: { data: new Float32Array(768).fill(1) } };
    },
    async release() {
      events.push(`${name}.release`);
      if (name === failRelease) throw new Error("release failed");
    },
  });
  const fork = () => {
    let onInit = null;
    const worker = { exited: null };
    const workerContext = vm.createContext({
      require(name) {
        if (name === "fs") return { readFileSync: () => JSON.stringify({ model: { vocab: {} } }) };
        if (name === "onnxruntime-node") return fakeOrt(events, nativeSession);
        return require(name);
      },
      process: {
        env: {},
        pid: 500 + workers.length,
        on() {},
        exit(code) {
          worker.exited = code;
        },
        parentPort: {
          once(_, callback) {
            onInit = callback;
          },
        },
      },
      setImmediate,
    });
    vm.runInContext(WORKER_SOURCE, workerContext);
    const child = new EventEmitter();
    child.pid = workerContext.process.pid;
    child.killed = false;
    child.kill = () => {
      child.killed = true;
      setImmediate(() => child.emit("exit", 0));
    };
    child.postMessage = (data, ports) => onInit({ data, ports });
    workers.push({ child, worker });
    setImmediate(() => child.emit("spawn"));
    return child;
  };
  const clientContext = vm.createContext({
    module: { exports: {} },
    __dirname: path.resolve("src/helpers"),
    process,
    setTimeout,
    clearTimeout,
    require(name) {
      if (name === "electron")
        return {
          app: { getPath: () => "/tmp" },
          MessageChannelMain: class {
            constructor() {
              this.port1 = new FakePort();
              this.port2 = new FakePort();
              this.port1.peer = this.port2;
              this.port2.peer = this.port1;
            }
          },
          utilityProcess: { fork },
        };
      if (name === "./debugLogger") return { debug() {}, info() {}, warn() {}, error() {} };
      return require(name);
    },
  });
  vm.runInContext(CLIENT_SOURCE, clientContext);
  const client = clientContext.module.exports;
  return {
    client,
    embeddings: loadEmbeddings(client),
    speaker: loadSpeakerEmbeddings(client, idleTimers),
    events,
    workers,
    async fireSpeakerIdleUnload() {
      idleTimers.findLast((timer) => !timer.cleared).callback();
      for (let i = 0; i < 10; i++) await nextTurn();
    },
  };
}

test("unloading the last session exits the worker and a later embedding respawns and reloads it", async () => {
  const h = createIntegratedHarness();
  await h.embeddings.embedText("");
  await h.embeddings.unload();
  assert.deepEqual(h.events, ["text.create", "text.release"]);
  assert.equal(h.workers.length, 1);
  assert.equal(h.workers[0].child.killed, true);
  assert.equal(h.client.child, null);
  assert.equal(h.workers[0].worker.exited, 0);
  assert.equal((await h.embeddings.embedText("")).length, 384);
  assert.equal(h.workers.length, 2);
  assert.deepEqual(h.events, ["text.create", "text.release", "text.create"]);
});

test("unloading text keeps the worker alive while diarization holds a speaker session", async () => {
  const h = createIntegratedHarness();
  await h.client.request("speaker.load", { modelPath: "speaker" });
  await h.embeddings.embedText("");
  await h.embeddings.unload();
  assert.equal(h.workers.length, 1);
  assert.equal(h.workers[0].child.killed, false);
  assert.ok(h.client.child);
  const { sessions } = await h.client.request("ping", {});
  assert.equal(sessions.speaker, true);
  assert.equal(sessions.text, false);
});

test("the speaker idle unload exits the worker once the text session is gone", async () => {
  const h = createIntegratedHarness();
  await h.speaker.extractEmbeddingFromSamples(SPEAKER_SAMPLES);
  await h.embeddings.embedText("");
  await h.embeddings.unload();
  assert.equal(h.workers[0].child.killed, false);
  await h.fireSpeakerIdleUnload();
  assert.equal(h.workers[0].child.killed, true);
  assert.deepEqual(h.events, ["speaker.create", "text.create", "text.release", "speaker.release"]);
  assert.ok(await h.speaker.extractEmbeddingFromSamples(SPEAKER_SAMPLES));
  assert.equal(h.workers.length, 2);
});

test("the speaker idle unload keeps the worker for a loaded text session", async () => {
  const h = createIntegratedHarness();
  await h.embeddings.embedText("");
  await h.speaker.extractEmbeddingFromSamples(SPEAKER_SAMPLES);
  await h.fireSpeakerIdleUnload();
  assert.equal(h.workers[0].child.killed, false);
  await h.embeddings.unload();
  assert.equal(h.workers[0].child.killed, true);
  assert.equal(h.workers.length, 1);
});

for (const session of ["speaker", "text"]) {
  test(`a ${session} release that throws still lets the worker exit`, async () => {
    const h = createIntegratedHarness({ failRelease: session });
    if (session === "speaker") {
      await h.speaker.extractEmbeddingFromSamples(SPEAKER_SAMPLES);
      await assert.rejects(h.speaker.unload(), /release failed/);
    } else {
      await h.embeddings.embedText("");
      await assert.rejects(h.embeddings.unload(), /release failed/);
    }
    assert.equal(h.workers[0].child.killed, true);
    assert.equal(h.client.child, null);
  });
}