Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.
JavaScript aianthropiccross-platformgeminigroqlinuxmacosnvidiaopen-sourceopenaiparakeetspeech-to-texttranscribewhisperwindows
fix(parakeet): Gate incompatible macOS runtime
Chadpiha0c271fefd5e9
diff --git a/.github/workflows/build-and-notarize.yml b/.github/workflows/build-and-notarize.ymlindex 4c8bf6f40..a451fb4c8 100644--- a/.github/workflows/build-and-notarize.yml+++ b/.github/workflows/build-and-notarize.yml@@ -375,6 +375,7 @@ jobs:donetest -x "$APP_PATH/Contents/Resources/bin/MediaRemoteAdapter.framework/Versions/A/MediaRemoteAdapter" || { echo "Missing in bundle: MediaRemoteAdapter.framework"; exit 1; }test -f "$APP_PATH/Contents/Resources/bin/mediaremote-adapter.pl" || { echo "Missing in bundle: mediaremote-adapter.pl"; exit 1; }+ node scripts/verify-macos-parakeet.js "$APP_PATH"- name: Upload Artifactsuses: actions/upload-artifact@v4diff --git a/.github/workflows/release.yml b/.github/workflows/release.ymlindex 15e34105d..38bd29e64 100644--- a/.github/workflows/release.yml+++ b/.github/workflows/release.yml@@ -378,6 +378,7 @@ jobs:for bin in macos-audio-tap macos-globe-listener macos-fast-paste macos-mic-listener macos-text-monitor macos-media-remote; dotest -x "$APP_PATH/Contents/Resources/bin/$bin" || { echo "Missing in bundle: $bin"; exit 1; }done+ node scripts/verify-macos-parakeet.js "$APP_PATH"- name: Upload arch-specific update metadataenv:diff --git a/scripts/download-sherpa-onnx.js b/scripts/download-sherpa-onnx.jsindex 8778cef73..900ee5aec 100644--- a/scripts/download-sherpa-onnx.js+++ b/scripts/download-sherpa-onnx.js@@ -9,6 +9,10 @@ const {parseArgs,setExecutable,} = require("./lib/download-utils");+const {+ PARAKEET_MINIMUM_MACOS_VERSION,+ compareVersions,+} = require("../src/helpers/parakeetCapability");const SHERPA_ONNX_VERSION = "1.13.4";const GITHUB_RELEASE_URL = `https://github.com/k2-fsa/sherpa-onnx/releases/download/v${SHERPA_ONNX_VERSION}`;@@ -62,6 +66,7 @@ const BINARIES = {const BIN_DIR = path.join(__dirname, "..", "resources", "bin");const VERSIONED_LIB_PATTERN = /^(lib.+?)\.(\d+\.\d+\.\d+)\.(dylib|so|dll)$/;+const REQUIRED_MACOS_ARCHITECTURES = ["x86_64", "arm64"];// Upstream 1.13.4 ships an invalid arm64 signature on libonnxruntime; dyld SIGKILLs unsigned loads.function adhocSign(filePath, platformArch) {@@ -73,6 +78,80 @@ function getDownloadUrl(archiveName) {return `${GITHUB_RELEASE_URL}/${archiveName}`;}+function parseMacosDeploymentTargets(vtoolOutput) {+ const targets = [];+ let architecture = null;+ let isMacosBuildVersion = false;++ for (const line of String(vtoolOutput).split("\n")) {+ const architectureMatch = line.match(/\(architecture ([^)]+)\):\s*$/);+ if (architectureMatch) {+ architecture = architectureMatch[1];+ isMacosBuildVersion = false;+ continue;+ }++ if (/^\s*platform MACOS\s*$/.test(line)) {+ isMacosBuildVersion = true;+ continue;+ }++ const minimumMatch = line.match(/^\s*minos (\S+)\s*$/);+ if (architecture && isMacosBuildVersion && minimumMatch) {+ targets.push({ architecture, minimumVersion: minimumMatch[1] });+ isMacosBuildVersion = false;+ }+ }++ return targets;+}++function validateMacosDeploymentTargets(targets) {+ const architectures = new Set(targets.map((target) => target.architecture));+ for (const architecture of REQUIRED_MACOS_ARCHITECTURES) {+ if (!architectures.has(architecture)) {+ throw new Error(`ONNX Runtime is missing required architecture: ${architecture}`);+ }+ }++ for (const target of targets) {+ if (compareVersions(target.minimumVersion, PARAKEET_MINIMUM_MACOS_VERSION) !== 0) {+ throw new Error(+ `${target.architecture} requires macOS ${target.minimumVersion}, but the Parakeet capability gate is ${PARAKEET_MINIMUM_MACOS_VERSION}`+ );+ }+ }++ return {+ architectures: [...architectures],+ minimumVersion: PARAKEET_MINIMUM_MACOS_VERSION,+ };+}++function verifyPackagedMacosParakeet(+ appPath,+ {+ readDirectory = fs.readdirSync,+ runVtool = (libraryPath) =>+ execFileSync("xcrun", ["vtool", "-show-build", libraryPath], { encoding: "utf8" }),+ } = {}+) {+ const binDirectory = path.join(appPath, "Contents", "Resources", "bin");+ const libraries = readDirectory(binDirectory).filter((fileName) =>+ /^libonnxruntime\.\d+(?:\.\d+)*\.dylib$/.test(fileName)+ );++ if (libraries.length !== 1) {+ throw new Error(+ `Expected one versioned ONNX Runtime library in ${binDirectory}, found ${libraries.length}`+ );+ }++ const libraryPath = path.join(binDirectory, libraries[0]);+ const targets = parseMacosDeploymentTargets(runVtool(libraryPath));+ return { ...validateMacosDeploymentTargets(targets), libraryPath };+}+function extractTarBz2(archivePath, destDir) {fs.mkdirSync(destDir, { recursive: true });// Use relative paths from archive dir as cwd, so neither -f nor -C args@@ -160,7 +239,10 @@ async function downloadBinary(platformArch, config, isForce = false) {const diarizeOutputPath = path.join(BIN_DIR, config.diarizeOutputName);const installMarkerPath = path.join(BIN_DIR, `.sherpa-onnx-${platformArch}.json`);- if (!isForce && isCompleteInstall(installMarkerPath, [outputPath, onlineOutputPath, diarizeOutputPath])) {+ if (+ !isForce &&+ isCompleteInstall(installMarkerPath, [outputPath, onlineOutputPath, diarizeOutputPath])+ ) {console.log(` ${platformArch}: Already exists (use --force to re-download)`);return true;}@@ -316,6 +398,9 @@ module.exports = {BINARIES,BIN_DIR,getDownloadUrl,+ parseMacosDeploymentTargets,+ validateMacosDeploymentTargets,+ verifyPackagedMacosParakeet,};// Only run main() when executed directlydiff --git a/scripts/verify-macos-parakeet.js b/scripts/verify-macos-parakeet.jsnew file mode 100644index 000000000..486b14425--- /dev/null+++ b/scripts/verify-macos-parakeet.js@@ -0,0 +1,19 @@+#!/usr/bin/env node+const path = require("path");+const { verifyPackagedMacosParakeet } = require("./download-sherpa-onnx");++const appPath = process.argv[2];+if (!appPath) {+ console.error("Usage: node scripts/verify-macos-parakeet.js <OpenWhispr.app>");+ process.exitCode = 1;+} else {+ try {+ const result = verifyPackagedMacosParakeet(path.resolve(appPath));+ console.log(+ `Verified Parakeet ONNX Runtime for ${result.architectures.join(", ")} at macOS ${result.minimumVersion}`+ );+ } catch (error) {+ console.error(`Parakeet compatibility validation failed: ${error.message}`);+ process.exitCode = 1;+ }+}diff --git a/src/components/TranscriptionModelPicker.tsx b/src/components/TranscriptionModelPicker.tsxindex 03d64483d..32ae74171 100644--- a/src/components/TranscriptionModelPicker.tsx+++ b/src/components/TranscriptionModelPicker.tsx@@ -39,6 +39,7 @@ import { API_ENDPOINTS, normalizeBaseUrl } from "../config/constants";import { GetApiKeyLink } from "./ui/GetApiKeyLink";import { getCachedPlatform } from "../utils/platform";import logger from "../utils/logger";+import type { ParakeetCheckResult } from "../types/electron";interface LocalModel {model: string;@@ -380,6 +381,7 @@ export default function TranscriptionModelPicker({const effectiveLocal = mode === "local" ? true : mode === "cloud" ? false : useLocalWhisper;const [localModels, setLocalModels] = useState<LocalModel[]>([]);const [parakeetModels, setParakeetModels] = useState<LocalModel[]>([]);+ const [parakeetCapability, setParakeetCapability] = useState<ParakeetCheckResult | null>(null);const [internalLocalProvider, setInternalLocalProvider] = useState(selectedLocalProvider);const hasLoadedRef = useRef(false);const hasLoadedParakeetRef = useRef(false);@@ -405,6 +407,30 @@ export default function TranscriptionModelPicker({}// eslint-disable-next-line react-hooks/exhaustive-deps -- sync prop→state: only re-run when the prop changes}, [selectedLocalProvider]);++ useEffect(() => {+ let cancelled = false;++ window.electronAPI+ ?.checkParakeetInstallation?.()+ .then((capability) => {+ if (!cancelled) setParakeetCapability(capability);+ })+ .catch((error) => {+ logger.error("Failed to check Parakeet compatibility", { error }, "models");+ });++ return () => {+ cancelled = true;+ };+ }, []);++ useEffect(() => {+ if (parakeetCapability?.supported !== false || internalLocalProvider !== "nvidia") return;++ setInternalLocalProvider("whisper");+ onLocalProviderSelect?.("whisper");+ }, [internalLocalProvider, onLocalProviderSelect, parakeetCapability]);const localModelsLoadQueueRef = useRef<Promise<void>>(Promise.resolve());const parakeetModelsLoadQueueRef = useRef<Promise<void>>(Promise.resolve());const loadLocalModelsRef = useRef<(() => Promise<void>) | null>(null);@@ -439,6 +465,21 @@ export default function TranscriptionModelPicker({);return filterByokProviderOptionsByPolicy(tabs, "transcription", policyState);}, [availableCloudProviders, policyState, streamingOnly, t]);+ const localProviderTabs = useMemo(+ () =>+ LOCAL_PROVIDER_TABS.map((provider) =>+ provider.id === "nvidia" && parakeetCapability?.supported === false+ ? {+ ...provider,+ disabled: true,+ disabledLabel: parakeetCapability.minimumMacOSVersion+ ? `macOS ${parakeetCapability.minimumMacOSVersion}+`+ : "Unavailable",+ }+ : provider+ ),+ [parakeetCapability]+ );useEffect(() => {selectedLocalModelRef.current = selectedLocalModel;@@ -765,12 +806,12 @@ export default function TranscriptionModelPicker({const handleLocalProviderChange = useCallback((providerId: string) => {- const tab = LOCAL_PROVIDER_TABS.find((t) => t.id === providerId);+ const tab = localProviderTabs.find((candidate) => candidate.id === providerId);if (tab?.disabled) return;setInternalLocalProvider(providerId);onLocalProviderSelect?.(providerId);},- [onLocalProviderSelect]+ [localProviderTabs, onLocalProviderSelect]);const handleWhisperModelSelect = useCallback(@@ -1188,7 +1229,7 @@ export default function TranscriptionModelPicker({) : (<><ProviderTabs- providers={LOCAL_PROVIDER_TABS}+ providers={localProviderTabs}selectedId={internalLocalProvider}onSelect={handleLocalProviderChange}colorScheme="purple"diff --git a/src/helpers/ipcHandlers.js b/src/helpers/ipcHandlers.jsindex 4de6743bc..214f8b666 100644--- a/src/helpers/ipcHandlers.js+++ b/src/helpers/ipcHandlers.js@@ -4,6 +4,7 @@ const fs = require("fs");const os = require("os");const crypto = require("crypto");const debugLogger = require("./debugLogger");+const { PARAKEET_UNSUPPORTED_OS_CODE } = require("./parakeetCapability");const { broadcastToWindows } = require("./windowBroadcast");const { resolveFailedGpuBackends } = require("./whisper");const { BYOK_API_KEYS } = require("../config/secretKeys");@@ -2610,7 +2611,6 @@ class IPCHandlers {message: errorMessage,};}-throw error;}});@@ -2946,6 +2946,13 @@ class IPCHandlers {message: errorMessage,};}+ if (error.code === PARAKEET_UNSUPPORTED_OS_CODE) {+ return {+ success: false,+ error: error.code,+ message: errorMessage,+ };+ }throw error;}diff --git a/src/helpers/parakeet.js b/src/helpers/parakeet.jsindex a18d61c7b..81245fb8a 100644--- a/src/helpers/parakeet.js+++ b/src/helpers/parakeet.js@@ -13,6 +13,7 @@ const {} = require("./downloadUtils");const ParakeetServerManager = require("./parakeetServer");const { getModelsDirForService } = require("./modelDirUtils");+const { assertParakeetSupported, getParakeetCapability } = require("./parakeetCapability");const modelRegistryData = require("../models/modelRegistryData.json");const { getModelRuntime, REQUIRED_MODEL_FILES } = require("./parakeetModelInfo");@@ -70,8 +71,10 @@ class ParakeetManager {await this.logDependencyStatus();const { localTranscriptionProvider, parakeetModel } = settings;+ const capability = getParakeetCapability();if (+ capability.supported &&localTranscriptionProvider === "nvidia" &¶keetModel &&this.serverManager.isAvailable(getModelRuntime(parakeetModel))@@ -99,8 +102,9 @@ class ParakeetManager {}} else {debugLogger.debug("Skipping parakeet server pre-warm", {- reason:- localTranscriptionProvider !== "nvidia"+ reason: !capability.supported+ ? capability.message+ : localTranscriptionProvider !== "nvidia"? "provider not nvidia": !parakeetModel? "no model selected"@@ -159,15 +163,29 @@ class ParakeetManager {async checkInstallation() {const binaryPath =this.serverManager.getBinaryPath("offline") || this.serverManager.getBinaryPath("online");+ const capability = getParakeetCapability();++ if (!capability.supported) {+ return {+ installed: !!binaryPath,+ working: false,+ ...capability,+ };+ }+if (!binaryPath) {- return { installed: false, working: false };+ return { installed: false, working: false, supported: true };}- return { installed: true, working: true, path: binaryPath };+ return { installed: true, working: true, supported: true, path: binaryPath };}async startServer(modelName) {this.validateModelName(modelName);+ const capability = getParakeetCapability();+ if (!capability.supported) {+ return { success: false, code: capability.code, reason: capability.message };+ }return this.serverManager.startServer(modelName);}@@ -185,6 +203,7 @@ class ParakeetManager {async createOnlineStream(modelName, options = {}) {this.validateModelName(modelName);+ assertParakeetSupported();const started = await this.serverManager.startServer(modelName);if (!started.success) {throw new Error(started.reason || "Failed to start parakeet streaming server");@@ -194,6 +213,7 @@ class ParakeetManager {async transcribeLocalParakeet(audioBlob, options = {}) {const model = options.model || "parakeet-tdt-0.6b-v3";+ assertParakeetSupported();const serverAvailable = this.serverManager.isAvailable(getModelRuntime(model));debugLogger.logSTTPipeline("transcribeLocalParakeet - start", {@@ -282,6 +302,7 @@ class ParakeetManager {async downloadParakeetModel(modelName, progressCallback = null) {this.validateModelName(modelName);+ assertParakeetSupported();const modelConfig = getParakeetModelConfig(modelName);const modelPath = this.getModelPath(modelName);diff --git a/src/helpers/parakeetCapability.js b/src/helpers/parakeetCapability.jsnew file mode 100644index 000000000..136d53a7e--- /dev/null+++ b/src/helpers/parakeetCapability.js@@ -0,0 +1,54 @@+const PARAKEET_MINIMUM_MACOS_VERSION = "15.5";+const PARAKEET_UNSUPPORTED_OS_CODE = "PARAKEET_UNSUPPORTED_OS";++function compareVersions(left, right) {+ const leftParts = String(left).split(".").map(Number);+ const rightParts = String(right).split(".").map(Number);+ const length = Math.max(leftParts.length, rightParts.length);++ for (let index = 0; index < length; index += 1) {+ const difference = (leftParts[index] || 0) - (rightParts[index] || 0);+ if (difference !== 0) return difference > 0 ? 1 : -1;+ }++ return 0;+}++function getParakeetCapability({ platform = process.platform, systemVersion } = {}) {+ if (platform !== "darwin") return { supported: true };++ const detectedVersion =+ systemVersion ??+ (typeof process.getSystemVersion === "function" ? process.getSystemVersion() : null);++ // Plain Node does not expose Electron's system-version API. Production main-process+ // calls always provide it; allowing Node keeps build tooling and unit tests portable.+ if (!detectedVersion || compareVersions(detectedVersion, PARAKEET_MINIMUM_MACOS_VERSION) >= 0) {+ return { supported: true };+ }++ return {+ supported: false,+ code: PARAKEET_UNSUPPORTED_OS_CODE,+ message: `Parakeet requires macOS ${PARAKEET_MINIMUM_MACOS_VERSION} or later. Use Whisper or cloud transcription on this Mac.`,+ minimumMacOSVersion: PARAKEET_MINIMUM_MACOS_VERSION,+ };+}++function assertParakeetSupported(options) {+ const capability = getParakeetCapability(options);+ if (capability.supported) return;++ throw Object.assign(new Error(capability.message), {+ code: capability.code,+ minimumMacOSVersion: capability.minimumMacOSVersion,+ });+}++module.exports = {+ PARAKEET_MINIMUM_MACOS_VERSION,+ PARAKEET_UNSUPPORTED_OS_CODE,+ compareVersions,+ getParakeetCapability,+ assertParakeetSupported,+};diff --git a/src/types/electron.ts b/src/types/electron.tsindex e94699d18..21f2dfd72 100644--- a/src/types/electron.ts+++ b/src/types/electron.ts@@ -667,7 +667,11 @@ export interface WhisperDownloadProgressData {export interface ParakeetCheckResult {installed: boolean;working: boolean;+ supported?: boolean;path?: string;+ code?: string;+ message?: string;+ minimumMacOSVersion?: string;}export interface ParakeetModelResult {diff --git a/test/helpers/parakeetCapability.test.js b/test/helpers/parakeetCapability.test.jsnew file mode 100644index 000000000..b89dc1c0a--- /dev/null+++ b/test/helpers/parakeetCapability.test.js@@ -0,0 +1,31 @@+const test = require("node:test");+const assert = require("node:assert/strict");++const { getParakeetCapability } = require("../../src/helpers/parakeetCapability");++test("Parakeet supports macOS at and above the packaged ONNX Runtime floor", () => {+ assert.deepEqual(getParakeetCapability({ platform: "darwin", systemVersion: "15.5" }), {+ supported: true,+ });+ assert.deepEqual(getParakeetCapability({ platform: "darwin", systemVersion: "15.6.1" }), {+ supported: true,+ });+});++test("Parakeet rejects macOS below the packaged ONNX Runtime floor", () => {+ assert.deepEqual(getParakeetCapability({ platform: "darwin", systemVersion: "12.7.6" }), {+ supported: false,+ code: "PARAKEET_UNSUPPORTED_OS",+ message:+ "Parakeet requires macOS 15.5 or later. Use Whisper or cloud transcription on this Mac.",+ minimumMacOSVersion: "15.5",+ });+});++test("Parakeet capability gating does not change Windows or Linux", () => {+ for (const platform of ["win32", "linux"]) {+ assert.deepEqual(getParakeetCapability({ platform, systemVersion: "1.0" }), {+ supported: true,+ });+ }+});diff --git a/test/helpers/parakeetDeploymentTarget.test.js b/test/helpers/parakeetDeploymentTarget.test.jsnew file mode 100644index 000000000..9f1fa0c7b--- /dev/null+++ b/test/helpers/parakeetDeploymentTarget.test.js@@ -0,0 +1,81 @@+const test = require("node:test");+const assert = require("node:assert/strict");++const sherpaDownloader = require("../../scripts/download-sherpa-onnx");++const UNIVERSAL_VTOOL_OUTPUT = `+/tmp/libonnxruntime.1.27.0.dylib (architecture x86_64):+Load command 10+ cmd LC_BUILD_VERSION+ platform MACOS+ minos 15.5+ sdk 15.5+/tmp/libonnxruntime.1.27.0.dylib (architecture arm64):+Load command 10+ cmd LC_BUILD_VERSION+ platform MACOS+ minos 15.5+ sdk 15.5+`;++test("parses deployment targets for both ONNX Runtime architecture slices", () => {+ const targets = sherpaDownloader.parseMacosDeploymentTargets?.(UNIVERSAL_VTOOL_OUTPUT);++ assert.deepEqual(targets, [+ { architecture: "x86_64", minimumVersion: "15.5" },+ { architecture: "arm64", minimumVersion: "15.5" },+ ]);+});++test("accepts a universal ONNX Runtime library matching the runtime capability gate", () => {+ const result = sherpaDownloader.validateMacosDeploymentTargets?.([+ { architecture: "x86_64", minimumVersion: "15.5" },+ { architecture: "arm64", minimumVersion: "15.5" },+ ]);++ assert.deepEqual(result, {+ architectures: ["x86_64", "arm64"],+ minimumVersion: "15.5",+ });+});++test("rejects an ONNX Runtime slice whose deployment target exceeds the runtime gate", () => {+ assert.throws(+ () =>+ sherpaDownloader.validateMacosDeploymentTargets([+ { architecture: "x86_64", minimumVersion: "15.5" },+ { architecture: "arm64", minimumVersion: "16.0" },+ ]),+ /arm64 requires macOS 16.0, but the Parakeet capability gate is 15.5/+ );+});++test("rejects a packaged ONNX Runtime library missing a universal architecture slice", () => {+ assert.throws(+ () =>+ sherpaDownloader.validateMacosDeploymentTargets([+ { architecture: "arm64", minimumVersion: "15.5" },+ ]),+ /missing required architecture: x86_64/+ );+});++test("validates the versioned ONNX Runtime library from a packaged app", () => {+ const appPath = "/tmp/OpenWhispr.app";+ const result = sherpaDownloader.verifyPackagedMacosParakeet?.(appPath, {+ readDirectory(directory) {+ assert.equal(directory, `${appPath}/Contents/Resources/bin`);+ return ["libonnxruntime.dylib", "libonnxruntime.1.27.0.dylib"];+ },+ runVtool(libraryPath) {+ assert.equal(libraryPath, `${appPath}/Contents/Resources/bin/libonnxruntime.1.27.0.dylib`);+ return UNIVERSAL_VTOOL_OUTPUT;+ },+ });++ assert.deepEqual(result, {+ architectures: ["x86_64", "arm64"],+ libraryPath: `${appPath}/Contents/Resources/bin/libonnxruntime.1.27.0.dylib`,+ minimumVersion: "15.5",+ });+});diff --git a/test/helpers/transcriptionModelDownloadStatus.test.js b/test/helpers/transcriptionModelDownloadStatus.test.jsindex 6fc276abc..4f49e0174 100644--- a/test/helpers/transcriptionModelDownloadStatus.test.js+++ b/test/helpers/transcriptionModelDownloadStatus.test.js@@ -23,6 +23,153 @@ function activeDownload(model, overrides = {}) {};}+function stubMacosVersion(t, version) {+ const platformDescriptor = Object.getOwnPropertyDescriptor(process, "platform");+ const systemVersionDescriptor = Object.getOwnPropertyDescriptor(process, "getSystemVersion");++ Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });+ Object.defineProperty(process, "getSystemVersion", {+ configurable: true,+ value: () => version,+ });++ t.after(() => {+ Object.defineProperty(process, "platform", platformDescriptor);+ if (systemVersionDescriptor) {+ Object.defineProperty(process, "getSystemVersion", systemVersionDescriptor);+ } else {+ delete process.getSystemVersion;+ }+ });+}++test("Parakeet reports its packaged runtime as unsupported on macOS below 15.5", async (t) => {+ stubMacosVersion(t, "12.7.6");+ const manager = new ParakeetManager();+ manager.serverManager.getBinaryPath = () => "/Applications/OpenWhispr.app/parakeet";++ const result = await manager.checkInstallation();++ assert.deepEqual(result, {+ installed: true,+ working: false,+ supported: false,+ code: "PARAKEET_UNSUPPORTED_OS",+ message:+ "Parakeet requires macOS 15.5 or later. Use Whisper or cloud transcription on this Mac.",+ minimumMacOSVersion: "15.5",+ });+});++test("Parakeet refuses explicit server startup on unsupported macOS", async (t) => {+ stubMacosVersion(t, "12.7.6");+ const manager = new ParakeetManager();+ const model = Object.keys(modelRegistryData.parakeetModels)[0];+ let startCalls = 0;+ manager.serverManager.startServer = async () => {+ startCalls += 1;+ return { success: true };+ };++ const result = await manager.startServer(model);++ assert.deepEqual(result, {+ success: false,+ code: "PARAKEET_UNSUPPORTED_OS",+ reason:+ "Parakeet requires macOS 15.5 or later. Use Whisper or cloud transcription on this Mac.",+ });+ assert.equal(startCalls, 0);+});++test("Parakeet refuses a missing-model download before filesystem or download setup", async (t) => {+ stubMacosVersion(t, "12.7.6");+ const manager = new ParakeetManager();+ const model = Object.keys(modelRegistryData.parakeetModels)[0];+ let modelStatusChecks = 0;+ let modelDirectoryChecks = 0;+ manager.serverManager.isModelDownloaded = () => {+ modelStatusChecks += 1;+ return false;+ };+ manager.getModelsDir = () => {+ modelDirectoryChecks += 1;+ throw new Error("unexpected model-directory access");+ };++ await assert.rejects(+ manager.downloadParakeetModel(model),+ (error) =>+ error.code === "PARAKEET_UNSUPPORTED_OS" &&+ error.message ===+ "Parakeet requires macOS 15.5 or later. Use Whisper or cloud transcription on this Mac."+ );+ assert.equal(modelStatusChecks, 0);+ assert.equal(modelDirectoryChecks, 0);+});++test("Parakeet refuses streaming startup on unsupported macOS", async (t) => {+ stubMacosVersion(t, "12.7.6");+ const manager = new ParakeetManager();+ const model = Object.keys(modelRegistryData.parakeetModels).find((candidate) =>+ manager.supportsOnlineStreaming(candidate)+ );+ let startCalls = 0;+ manager.serverManager.startServer = async () => {+ startCalls += 1;+ return { success: true };+ };++ await assert.rejects(+ manager.createOnlineStream(model),+ (error) => error.code === "PARAKEET_UNSUPPORTED_OS"+ );+ assert.equal(startCalls, 0);+});++test("Parakeet refuses transcription before touching the sidecar on unsupported macOS", async (t) => {+ stubMacosVersion(t, "12.7.6");+ const manager = new ParakeetManager();+ const model = Object.keys(modelRegistryData.parakeetModels)[0];+ let transcribeCalls = 0;+ manager.serverManager.isAvailable = () => true;+ manager.serverManager.isModelDownloaded = () => true;+ manager.serverManager.transcribe = async () => {+ transcribeCalls += 1;+ return { text: "unexpected" };+ };++ await assert.rejects(+ manager.transcribeLocalParakeet(Buffer.from("audio"), { model }),+ (error) => error.code === "PARAKEET_UNSUPPORTED_OS"+ );+ assert.equal(transcribeCalls, 0);+});++test("Parakeet skips startup prewarming on unsupported macOS", async (t) => {+ stubMacosVersion(t, "12.7.6");+ const modelsDir = await fs.mkdtemp(path.join(os.tmpdir(), "openwhispr-parakeet-capability-"));+ t.after(() => fs.rm(modelsDir, { recursive: true, force: true }));+ const manager = new ParakeetManager();+ const model = Object.keys(modelRegistryData.parakeetModels)[0];+ let startCalls = 0;+ manager.getModelsDir = () => modelsDir;+ manager.logDependencyStatus = async () => {};+ manager.serverManager.isAvailable = () => true;+ manager.serverManager.isModelDownloaded = () => true;+ manager.serverManager.startServer = async () => {+ startCalls += 1;+ return { success: true };+ };++ await manager.initializeAtStartup({+ localTranscriptionProvider: "nvidia",+ parakeetModel: model,+ });++ assert.equal(startCalls, 0);+});+test("listParakeetModels surfaces active installation state", async () => {const manager = new ParakeetManager();const model = Object.keys(modelRegistryData.parakeetModels)[0];