arcane-os 0.64.0 → 0.66.0

package/src/local-ai/whisper/index.mjs

@@ -37,6 +37,9 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
             requestedBackend: helper?.variant.backend ?? runtime?.backend ?? 'auto',
             observedBackend: helper?.metadata?.observedBackend ?? null,
             backendEvidence: helper?.metadata?.backendEvidence ?? null,
+            requestedEncoder: runtime?.encoder === 'openvino-npu' ? 'NPU' : null,
+            observedEncoder: helper?.metadata?.observedEncoder ?? null,
+            encoderEvidence: helper?.metadata?.encoderEvidence ?? null,
             error: error ? {code: error.code, message: error.message} : null
         };
     }
@@ -80,6 +83,11 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
         const library = variant.libraryDirectory ?? variant.root;
         const args = ['--model-base64', encode(model.path), '--runtime-base64', encode(library),
             '--backend', variant.backend === 'cpu' ? 'cpu' : 'gpu'];
+        if (runtime.encoder === 'openvino-npu') {
+            args.push('--encoder-model-base64', encode(model.encoderPath),
+                '--encoder-cache-base64', encode(path.join(temporaryDirectory, 'encoder-cache')),
+                '--encoder-device', 'NPU');
+        }
         if (runtime.threads !== undefined) args.push('--threads', String(runtime.threads));
 
         async function receive({stream, chunk}) {
@@ -96,7 +104,7 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
                         session.metadata = record;
                         readiness.resolve(record);
                     } else if (record.type === 'error' && !record.requestId) {
-                        readiness.reject(whisperError('WHISPER_MODEL_FAILED', record.message));
+                        readiness.reject(whisperError(record.code ?? 'WHISPER_MODEL_FAILED', record.message));
                     } else if (pending && record.requestId === pending.id) {
                         if (record.type === 'complete') {
                             pending.response.resolve({text: record.text, language: record.language,
@@ -179,7 +187,7 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
                 session.input.end();
             }
         }
-        try { await session.completion; }
+        try { return await session.completion; }
         catch (failure) {
             if (!session.controller.signal.aborted) throw failure;
         }
@@ -217,6 +225,13 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
             }
             const model = runtime.models?.find(function selectedModel(record) { return record.id === selected; });
             if (!model) throw whisperError('WHISPER_MODEL_UNAVAILABLE', `The selected model ${selected} is not prepared.`);
+            if (runtime.encoder === 'openvino-npu') {
+                if (!is.string(model.encoderPath) || !is.string(model.encoderDataPath)) {
+                    throw whisperError('WHISPER_ENCODER_UNAVAILABLE', 'The selected NPU model requires its matching OpenVINO XML and BIN files.');
+                }
+                await mkdir(path.join(temporaryDirectory, 'encoder-cache'), {recursive: true});
+                loadSignal.throwIfAborted();
+            }
             const variants = selectedVariants(runtime);
             const failures = [];
             for (const variant of variants) {
@@ -236,8 +251,13 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
                     failures.push(failure);
                     try { await stopHelper(session, {terminate: true}); }
                     catch (exitFailure) { if (exitFailure !== failure) failures.push(exitFailure); }
+                    if (runtime.encoder === 'openvino-npu') {
+                        try { await session.completion; }
+                        catch (exitFailure) { if (exitFailure !== failure) failure.cause = exitFailure; }
+                    }
                     helper = null;
                     loadSignal.throwIfAborted();
+                    if (failure.code === 'WHISPER_ENCODER_UNAVAILABLE') throw failure;
                     if (session.observerFailure || failure.code === 'WHISPER_PROTOCOL_INCOMPLETE') throw failure;
                     if (variant !== variants[variants.length - 1] && onEvent) {
                         await onEvent({type: 'whisper.backend.failed', message: failure.message,
@@ -247,7 +267,10 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
                     loadSignal.removeEventListener('abort', cancelLoading);
                 }
             }
-            throw new AggregateError(failures, 'The selected Whisper model could not load in the prepared runtimes.');
+            if (runtime.encoder === 'openvino-npu' && failures.length === 1) throw failures[0];
+            const failure = new AggregateError(failures, 'The selected Whisper model could not load in the prepared runtimes.');
+            if (runtime.encoder === 'openvino-npu') failure.code = failures[0]?.code ?? 'WHISPER_MODEL_FAILED';
+            throw failure;
         }).catch(function modelLoadFailed(failure) {
             error = loadSignal.aborted ? null : failure;
             state = unloading || closing ? 'unloading' : loadSignal.aborted ? 'unloaded' : 'error';
@@ -265,7 +288,7 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
             || session.observerFailure || failure.code === 'WHISPER_PROTOCOL_INCOMPLETE'
             || (runtime.backend && runtime.backend !== 'auto')) return null;
         if (failure.code !== 'WHISPER_INFERENCE_FAILED' && !session.failed) return null;
-        return runtime.variants.find(function preparedCPU(variant) { return variant.backend === 'cpu'; }) ?? null;
+        return selectedVariants(runtime).find(function preparedCPU(variant) { return variant.backend === 'cpu'; }) ?? null;
     }
 
     function transcribe(request, {signal, onProgress, requestId: suppliedRequestId} = {}) {
@@ -384,6 +407,13 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
         const response = deferred();
         session.pending = {id, response, signal, onProgress, attempt};
         function cancelInference() {
+            if (runtime.encoder === 'openvino-npu') {
+                // OpenVINO's synchronous encoder call has no cancellation seam
+                // in whisper.cpp. Retire the owned process and join its exit.
+                session.stopping = true;
+                session.controller.abort(signal.reason);
+                return;
+            }
             writeCommand(session.input, `cancel\t${id}\n`).catch(function cancellationWriteFailed(failure) {
                 session.controller.abort(failure);
             });
@@ -398,6 +428,29 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
             signal.throwIfAborted();
             return result;
         } catch (failure) {
+            if (runtime.encoder === 'openvino-npu' && failure.code === 'WHISPER_INFERENCE_FAILED') {
+                const recovering = cpuRecoveryVariant(session, failure);
+                try { failure.data = await stopHelper(session); }
+                catch (exitFailure) { if (exitFailure !== failure) failure.cause = exitFailure; }
+                if (helper === session) {
+                    helper = null;
+                    state = unloading || closing ? 'unloading' : signal.aborted ? 'unloaded' : recovering ? 'recovering' : 'error';
+                    error = signal.aborted || recovering ? null : failure;
+                    publish();
+                }
+                signal.throwIfAborted();
+                throw failure;
+            }
+            if (signal.aborted && runtime.encoder === 'openvino-npu') {
+                await stopHelper(session, {terminate: true});
+                if (helper === session) {
+                    helper = null;
+                    state = unloading || closing ? 'unloading' : 'unloaded';
+                    error = null;
+                    publish();
+                }
+                signal.throwIfAborted();
+            }
             if (!response.settled) {
                 session.controller.abort(failure);
                 await Promise.allSettled([session.completion]);
@@ -453,7 +506,11 @@ export function createWhisperRuntime({runtime, prepare, modelId, temporaryDirect
 }
 
 function selectedVariants(runtime) {
-    const variants = runtime.variants ?? [];
+    const variants = (runtime.variants ?? []).filter(function matchingEncoder(variant) {
+        return runtime.encoder === 'openvino-npu'
+            ? variant.encoder === 'openvino-npu'
+            : variant.encoder === undefined;
+    });
     if (runtime.backend && runtime.backend !== 'auto') {
         const selected = variants.filter(function selectedBackend(variant) { return variant.backend === runtime.backend; });
         if (selected.length) return selected;

package/src/local-ai/whisper/install.mjs

@@ -29,7 +29,10 @@ export async function installedWhisperRuntime(record, signal, includeModels = tr
         files.push(variant.executable);
         directories.push(variant.root, variant.libraryDirectory);
     }
-    if (includeModels) for (const model of record.models) files.push(model.path);
+    if (includeModels) for (const model of record.models) {
+        files.push(model.path);
+        if (record.encoder === 'openvino-npu') files.push(model.encoderPath, model.encoderDataPath);
+    }
     for (const location of directories) {
         throwIfAborted(signal);
         if (!is.string(location) || !(await stat(location)).isDirectory()) return false;
@@ -104,6 +107,17 @@ function defaultWhisperVariants(requirement, platform, architecture) {
     if (platform !== 'win32' || architecture !== 'x64' || requirement.version !== '1.9.4') {
         throw new ArcaneError(ERROR_CODES.targetUnavailable, `Automatic Whisper distributions are available for 1.9.4 on win32/x64. Supply complete runtime variants for ${requirement.version} on ${platform}/${architecture}.`);
     }
+    if (requirement.encoder === 'openvino-npu') {
+        if (requirement.backend === 'metal') {
+            throw new ArcaneError(ERROR_CODES.targetUnavailable, 'The selected Windows OpenVINO Whisper distribution has no Metal decoder backend.');
+        }
+        const version = requirement.helperVersion ?? packageMetadata.version;
+        return [{
+            backend: requirement.backend === 'cpu' ? 'cpu' : 'cuda',
+            encoder: 'openvino-npu',
+            url: `https://github.com/TheWizardNexus/arcane-os-sdk/releases/download/${version}/arcane-whisper-openvino-windows-x64.tar.gz`
+        }];
+    }
     if (requirement.backend === 'metal') {
         throw new ArcaneError(ERROR_CODES.targetUnavailable, 'The selected Windows Whisper distribution has no Metal backend.');
     }
@@ -125,7 +139,10 @@ export async function installWhisperDistribution(requirement, options) {
     const controller = new AbortController();
     const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
     const preparation = {...options, signal};
-    const variants = reusable?.runtime.variants ?? defaultWhisperVariants(requirement, platform, architecture);
+    const integratedEncoder = requirement.encoder === 'openvino-npu' && !requirement.variants;
+    const variants = reusable
+        ? integratedEncoder ? [reusable.runtime.variants[0]] : reusable.runtime.variants
+        : defaultWhisperVariants(requirement, platform, architecture);
     if (!requirement.helperExecutable && !requirement.helperUrl && (platform !== 'win32' || architecture !== 'x64')) {
         throw new ArcaneError(ERROR_CODES.targetUnavailable, `Supply the Arcane Whisper helperExecutable or helperUrl for ${platform}/${architecture}.`);
     }
@@ -133,7 +150,7 @@ export async function installWhisperDistribution(requirement, options) {
         throw new ArcaneError(ERROR_CODES.targetUnavailable, `Supply a complete decoder tree through decoderExecutable and decoderRoot, or decoderUrl, for ${platform}/${architecture}.`);
     }
     const helperName = `arcane-whisper${platform === 'win32' ? '.exe' : ''}`;
-    const helperRoot = path.join(root, 'helper');
+    let helperRoot = path.join(root, 'helper');
     let helperExecutable = path.join(helperRoot, helperName);
     const decoderRoot = path.join(root, 'decoder');
     const models = [];
@@ -151,10 +168,18 @@ export async function installWhisperDistribution(requirement, options) {
             else await prepareWhisperArchive(variant.url, variantRoot, preparation);
             const libraryName = platform === 'win32' ? 'whisper.dll' : platform === 'darwin' ? 'libwhisper.dylib' : 'libwhisper.so';
             const libraryDirectory = selectedLibraryDirectory ?? path.dirname(await findWhisperFile(variantRoot, libraryName, signal));
-            preparedVariants[index] = {backend: variant.backend, root: variantRoot, libraryDirectory};
+            preparedVariants[index] = {backend: variant.backend, root: variantRoot, libraryDirectory,
+                ...(variant.encoder ? {encoder: variant.encoder} : {})};
+            if (requirement.encoder === 'openvino-npu' && !requirement.helperExecutable && !requirement.helperUrl) {
+                preparedVariants[index].executable = await findWhisperFile(variantRoot, helperName, signal);
+            }
         };
     });
     jobs.push(async function prepareHelper() {
+        // The optional native asset owns its matching helper and runtime as
+        // one complete tree. Reuse that tree once and resolve its helper after
+        // variant preparation joins, including when models change later.
+        if (requirement.encoder === 'openvino-npu' && !requirement.helperExecutable && !requirement.helperUrl) return;
         const existingHelper = reusable?.runtime.helperExecutable ?? requirement.helperExecutable;
         if (existingHelper) {
             const source = path.resolve(existingHelper);
@@ -190,25 +215,46 @@ export async function installWhisperDistribution(requirement, options) {
         jobs.push(async function prepareSelectedModel() {
             const modelRoot = path.join(root, 'models', String(index));
             await mkdir(modelRoot, {recursive: true});
-            const filename = model.path ? path.basename(model.path) : model.filename ?? path.posix.basename(new URL(model.url).pathname);
-            const destination = path.join(modelRoot, filename);
             const priorIndex = reusable?.requirement.models.findIndex(function sameSelectedModel(candidate) {
                 return JSON.stringify(candidate) === JSON.stringify(model);
             }) ?? -1;
-            let source = model.path;
+            let sourceModel = model;
             if (priorIndex >= 0) {
-                const priorPath = reusable.runtime.models[priorIndex]?.path;
-                if (priorPath) {
+                const prior = reusable.runtime.models[priorIndex];
+                if (prior?.path) {
                     try {
-                        if ((await stat(priorPath)).isFile()) source = priorPath;
+                        const paths = [prior.path, ...(requirement.encoder === 'openvino-npu' ? [prior.encoderPath, prior.encoderDataPath] : [])];
+                        let available = true;
+                        for (const location of paths) if (!location || !(await stat(location)).isFile()) available = false;
+                        if (available) sourceModel = prior;
                     } catch (error) {
                         if (error.code !== 'ENOENT') throw error;
                     }
                 }
             }
-            if (source) await copyFile(path.resolve(source), destination);
+            if (!sourceModel.path && model.archiveUrl) {
+                await prepareWhisperArchive(model.archiveUrl, modelRoot, preparation);
+                models[index] = {...model,
+                    path: await findWhisperFile(modelRoot, model.filename, signal),
+                    ...(requirement.encoder === 'openvino-npu' ? {
+                        encoderPath: await findWhisperFile(modelRoot, model.encoderFilename, signal),
+                        encoderDataPath: await findWhisperFile(modelRoot, model.encoderDataFilename, signal)
+                    } : {})};
+                return;
+            }
+            const filename = sourceModel.path ? path.basename(sourceModel.path) : model.filename ?? path.posix.basename(new URL(model.url).pathname);
+            const destination = path.join(modelRoot, filename);
+            if (sourceModel.path) await copyFile(path.resolve(sourceModel.path), destination);
             else await downloadWhisperResource(model.url, destination, preparation);
-            models[index] = {...model, path: destination};
+            const preparedModel = {...model, path: destination};
+            if (requirement.encoder === 'openvino-npu') {
+                for (const field of ['encoderPath', 'encoderDataPath']) {
+                    throwIfAborted(signal);
+                    preparedModel[field] = path.join(modelRoot, path.basename(sourceModel[field]));
+                    await copyFile(path.resolve(sourceModel[field]), preparedModel[field]);
+                }
+            }
+            models[index] = preparedModel;
         });
     }
     let nextJob = 0;
@@ -232,16 +278,26 @@ export async function installWhisperDistribution(requirement, options) {
     throwIfAborted(options.signal);
     if (failures.length === 1) throw failures[0];
     if (failures.length > 1) throw new AggregateError(failures, 'Whisper dependency preparation failed.');
+    if (requirement.encoder === 'openvino-npu' && !requirement.helperExecutable && !requirement.helperUrl) {
+        helperRoot = preparedVariants[0].root;
+        helperExecutable = preparedVariants[0].executable;
+    }
+    // The precompiled optional tree owns both decoder backends. Share its
+    // helper and native files while keeping the normal GPU-first CPU recovery.
+    if (integratedEncoder && requirement.backend === 'auto') {
+        preparedVariants.push({...preparedVariants[0], backend: 'cpu'});
+    }
     const locations = {
         version: requirement.version,
         backend: requirement.backend,
+        ...(requirement.encoder ? {encoder: requirement.encoder} : {}),
         helperRoot,
         helperExecutable,
         helperVersion: requirement.helperVersion ?? packageMetadata.version,
         decoderRoot,
         decoderExecutable,
         variants: preparedVariants.map(function completedWhisperVariant(variant) {
-            return {...variant, executable: helperExecutable};
+            return {...variant, executable: variant.executable ?? helperExecutable};
         }),
         models,
         ...(requirement.modelId ? {modelId: requirement.modelId} : models.length === 1 ? {modelId: models[0].id} : {})
@@ -268,7 +324,9 @@ export function bundledWhisperRuntime(runtime, relativeRoot) {
             return {...variant, root: bundledWhisperPath(variant.root), libraryDirectory: bundledWhisperPath(variant.libraryDirectory), executable: bundledWhisperPath(variant.executable)};
         }),
         models: runtime.models.map(function bundledWhisperModel(model) {
-            return {...model, path: bundledWhisperPath(model.path)};
+            return {...model, path: bundledWhisperPath(model.path),
+                ...(model.encoderPath ? {encoderPath: bundledWhisperPath(model.encoderPath)} : {}),
+                ...(model.encoderDataPath ? {encoderDataPath: bundledWhisperPath(model.encoderDataPath)} : {})};
         })
     };
 }

package/src/local-ai/whisper/native/main.cpp

@@ -30,6 +30,9 @@ struct Configuration {
     std::string model;
     std::string runtime;
     std::string backend = "gpu";
+    std::string encoder_model;
+    std::string encoder_cache;
+    std::string encoder_device;
     int threads = 1;
 };
 
@@ -393,6 +396,12 @@ Configuration read_configuration(int argc, char** argv) {
             configuration.runtime = decode_base64(value);
         } else if (option == "--backend") {
             configuration.backend = value;
+        } else if (option == "--encoder-model-base64") {
+            configuration.encoder_model = decode_base64(value);
+        } else if (option == "--encoder-cache-base64") {
+            configuration.encoder_cache = decode_base64(value);
+        } else if (option == "--encoder-device") {
+            configuration.encoder_device = value;
         } else if (option == "--threads") {
             configuration.threads = std::stoi(value);
         } else {
@@ -405,6 +414,12 @@ Configuration read_configuration(int argc, char** argv) {
     if (configuration.backend != "gpu" && configuration.backend != "cpu") {
         throw std::runtime_error("The requested backend must be gpu or cpu.");
     }
+    if (!configuration.encoder_model.empty() || !configuration.encoder_cache.empty()
+            || !configuration.encoder_device.empty()) {
+        if (configuration.encoder_device != "NPU" || configuration.encoder_model.empty()) {
+            throw std::runtime_error("The OpenVINO encoder requires its selected model path and NPU device.");
+        }
+    }
     if (configuration.threads < 1) {
         throw std::runtime_error("Native inference requires a positive thread count.");
     }
@@ -416,7 +431,9 @@ int serve(const Configuration& configuration) {
     whisper_log_set(native_log, &log);
     emit("{\"type\":\"loading\",\"model\":" + json_string(configuration.model)
         + ",\"requestedBackend\":" + json_string(configuration.backend)
-        + ",\"observedBackend\":null,\"backendEvidence\":null}");
+        + ",\"observedBackend\":null,\"backendEvidence\":null"
+        + ",\"requestedEncoder\":" + (configuration.encoder_device.empty() ? "null" : json_string(configuration.encoder_device))
+        + ",\"observedEncoder\":null,\"encoderEvidence\":null}");
     ggml_backend_load_all_from_path(configuration.runtime.c_str());
     whisper_context_params parameters = whisper_context_default_params();
     parameters.use_gpu = configuration.backend == "gpu";
@@ -425,15 +442,29 @@ int serve(const Configuration& configuration) {
     if (!context) {
         throw std::runtime_error("Whisper could not load the selected model.");
     }
+    if (!configuration.encoder_device.empty()) {
+        const int result = whisper_ctx_init_openvino_encoder(context.get(), configuration.encoder_model.c_str(),
+            "NPU", configuration.encoder_cache.empty() ? nullptr : configuration.encoder_cache.c_str());
+        if (result != 0) {
+            emit_error("", "whisper_ctx_init_openvino_encoder for NPU returned " + std::to_string(result) + ".",
+                "WHISPER_ENCODER_UNAVAILABLE");
+            return 1;
+        }
+    }
     {
         const std::lock_guard<std::mutex> lock(log.mutex);
         // The public C API exposes available devices, not a context backend
         // getter. This observation is explicitly attributed to completed native
         // initialization logs; it does not claim every operation uses a GPU.
+        // A successful OpenVINO call establishes encoder initialization on the
+        // explicit NPU device, independently of decoder/backend observation.
         emit("{\"type\":\"ready\",\"model\":" + json_string(configuration.model)
             + ",\"requestedBackend\":" + json_string(configuration.backend)
             + ",\"observedBackend\":" + (log.backend.empty() ? "null" : json_string(log.backend))
-            + ",\"backendEvidence\":" + (log.backend.empty() ? "null" : "\"runtime-log\"") + "}");
+            + ",\"backendEvidence\":" + (log.backend.empty() ? "null" : "\"runtime-log\"")
+            + ",\"requestedEncoder\":" + (configuration.encoder_device.empty() ? "null" : json_string(configuration.encoder_device))
+            + ",\"observedEncoder\":" + (configuration.encoder_device.empty() ? "null" : json_string(configuration.encoder_device))
+            + ",\"encoderEvidence\":" + (configuration.encoder_device.empty() ? "null" : "\"openvino-initialization\"") + "}");
     }
     Commands commands;
     std::thread reader(read_commands, std::ref(commands));

package/src/local-ai/whisper/openvino-build.mjs

@@ -0,0 +1,138 @@
+import path from 'node:path';
+import {cp, mkdir, readdir, readFile, writeFile} from 'node:fs/promises';
+import Is from 'strong-type';
+import {runProcess} from '../../process.mjs';
+
+const is = new Is(false);
+
+/** Produce the optional Windows Intel NPU encoder runtime from installed upstream sources. */
+export async function buildWhisperOpenVinoRuntime({
+    sourceDirectory,
+    openvinoDirectory,
+    cudaDirectory,
+    outputRoot,
+    cmake = 'cmake',
+    generator,
+    cmakeArgs = [],
+    env,
+    signal,
+    onEvent
+} = {}) {
+    if (!is.string(sourceDirectory) || !is.string(openvinoDirectory) || !is.string(outputRoot)) {
+        throw new TypeError('Whisper sourceDirectory, OpenVINO openvinoDirectory, and outputRoot are required.');
+    }
+    if (process.platform !== 'win32' || process.arch !== 'x64') {
+        throw new Error('This optional OpenVINO producer currently targets Windows x64.');
+    }
+    const output = path.resolve(outputRoot);
+    const source = path.join(output, 'source');
+    const build = path.join(output, 'build');
+    const root = path.join(output, 'runtime');
+    const libraryDirectory = path.join(root, 'bin');
+    const toolkit = path.resolve(openvinoDirectory);
+    const options = {env, signal, onEvent};
+    signal?.throwIfAborted();
+    await cp(path.resolve(sourceDirectory), source, {recursive: true});
+    signal?.throwIfAborted();
+    await prepareOpenVinoSource(source);
+    const configure = await runProcess(cmake, [
+        '-S', source,
+        '-B', build,
+        ...(generator ? ['-G', generator] : []),
+        '-DCMAKE_BUILD_TYPE=Release',
+        `-DCMAKE_RUNTIME_OUTPUT_DIRECTORY=${path.join(build, 'bin')}`,
+        `-DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE=${path.join(build, 'bin')}`,
+        '-DBUILD_SHARED_LIBS=ON',
+        '-DWHISPER_OPENVINO=ON',
+        '-DWHISPER_BUILD_IS_DEV=OFF',
+        '-DWHISPER_BUILD_TESTS=OFF',
+        '-DWHISPER_BUILD_EXAMPLES=OFF',
+        '-DWHISPER_BUILD_SERVER=OFF',
+        '-DGGML_BACKEND_DL=ON',
+        '-DGGML_CPU=ON',
+        '-DGGML_NATIVE=OFF',
+        '-DGGML_CUDA=OFF',
+        '-DGGML_OPENVINO=OFF',
+        '-DGGML_OPENMP_FETCH=OFF',
+        '-DGGML_CCACHE=OFF',
+        `-DOpenVINO_DIR=${path.join(toolkit, 'runtime', 'cmake')}`,
+        ...cmakeArgs
+    ], options);
+    const compile = await runProcess(cmake, [
+        '--build', build, '--config', 'Release', '--target', 'whisper', 'ggml-cpu'
+    ], options);
+    signal?.throwIfAborted();
+    await mkdir(libraryDirectory, {recursive: true});
+    await mkdir(path.join(root, 'lib'), {recursive: true});
+    await mkdir(path.join(root, 'notices', 'whisper.cpp'), {recursive: true});
+    // Keep all selected upstream runtime DLLs together for Windows and plugin lookup.
+    await cp(path.join(build, 'bin'), libraryDirectory, {recursive: true});
+    await copyImportLibraries(build, path.join(root, 'lib'));
+    await cp(path.join(toolkit, 'runtime', 'bin', 'intel64', 'Release'), libraryDirectory, {recursive: true});
+    const tbbDirectory = path.join(toolkit, 'runtime', '3rdparty', 'tbb', 'bin');
+    for (const member of await readdir(tbbDirectory, {withFileTypes: true})) {
+        if (member.isFile() && member.name.endsWith('.dll') && !member.name.endsWith('_debug.dll')) {
+            await cp(path.join(tbbDirectory, member.name), path.join(libraryDirectory, member.name));
+        }
+    }
+    if (cudaDirectory) {
+        // The matching upstream plugin supplies CUDA without compiling a new backend.
+        for (const name of [
+            'ggml-cuda.dll', 'cublas64_12.dll', 'cublasLt64_12.dll', 'cudart64_12.dll',
+            'nvblas64_12.dll', 'nvrtc-builtins64_124.dll', 'nvrtc64_120_0.dll'
+        ]) {
+            await cp(path.join(cudaDirectory, name), path.join(libraryDirectory, name));
+        }
+    }
+    await cp(path.join(toolkit, 'docs', 'licensing'), path.join(root, 'notices', 'openvino'), {recursive: true});
+    await cp(path.join(source, 'LICENSE'), path.join(root, 'notices', 'whisper.cpp', 'LICENSE'));
+    await writeFile(path.join(root, 'notices', 'whisper.cpp', 'CHANGES.txt'),
+        'whisper.cpp 1.9.4: propagate OpenVINO encoder inference failure and send both OpenVINO exception diagnostics to stderr.\n');
+    signal?.throwIfAborted();
+    return {
+        version: '1.9.4',
+        openvinoVersion: '2026.3.1',
+        platform: process.platform,
+        architecture: process.arch,
+        encoder: 'openvino-npu',
+        backend: cudaDirectory ? 'cuda' : 'cpu',
+        backends: cudaDirectory ? ['cuda', 'cpu'] : ['cpu'],
+        root,
+        directory: root,
+        libraryDirectory,
+        sourceDirectory: source,
+        diagnostics: {configure, compile}
+    };
+}
+
+async function prepareOpenVinoSource(source) {
+    const whisperPath = path.join(source, 'src', 'whisper.cpp');
+    const encoderPath = path.join(source, 'src', 'openvino', 'whisper-openvino-encoder.cpp');
+    const whisper = await readFile(whisperPath, 'utf8');
+    const call = '            whisper_openvino_encode(wstate.ctx_openvino, mel, wstate.embd_enc);';
+    if (!whisper.includes(call)) {
+        throw new Error('The selected Whisper source does not contain the expected OpenVINO encoder call.');
+    }
+    await writeFile(whisperPath, whisper.replace(call,
+        '            if (!whisper_openvino_encode(wstate.ctx_openvino, mel, wstate.embd_enc)) {\n                return false;\n            }'));
+    const encoder = await readFile(encoderPath, 'utf8');
+    const compileDiagnostic = 'std::cout << "in openvino encoder compile routine: exception: "';
+    const inferenceDiagnostic = 'std::cout << "in openvino encode inference execution routine: exception: "';
+    if (!encoder.includes(compileDiagnostic) || !encoder.includes(inferenceDiagnostic)) {
+        throw new Error('The selected Whisper source does not contain both expected OpenVINO diagnostics.');
+    }
+    await writeFile(encoderPath, encoder
+        .replace(compileDiagnostic, compileDiagnostic.replace('std::cout', 'std::cerr'))
+        .replace(inferenceDiagnostic, inferenceDiagnostic.replace('std::cout', 'std::cerr')));
+}
+
+async function copyImportLibraries(directory, destination) {
+    for (const member of await readdir(directory, {withFileTypes: true})) {
+        const source = path.join(directory, member.name);
+        if (member.isDirectory()) {
+            await copyImportLibraries(source, destination);
+        } else if (member.name === 'whisper.lib' || /^ggml(?:-.*)?\.lib$/.test(member.name)) {
+            await cp(source, path.join(destination, member.name));
+        }
+    }
+}