arcane-os 0.93.0 → 0.95.0

package/src/local-ai/kokoro/native/CMakeLists.txt

@@ -0,0 +1,45 @@
+cmake_minimum_required(VERSION 3.26)
+project(ArcaneKokoroFrontend LANGUAGES CXX)
+
+# The producer builds the disclosed upstream projects through their own build systems.
+# This target consumes their public headers/static libraries; it acquires nothing.
+set(ESPEAK_NG_INCLUDE_DIRECTORY "" CACHE PATH "Public include directory containing espeak-ng/speak_lib.h")
+set(ESPEAK_NG_LIBRARY "" CACHE FILEPATH "Matching static espeak-ng library")
+set(UCD_LIBRARY "" CACHE FILEPATH "Matching eSpeak Unicode character database static library")
+set(OPUS_INCLUDE_DIRECTORY "" CACHE PATH "Public include directory containing opus.h")
+set(OPUS_LIBRARY "" CACHE FILEPATH "Disclosed libopus 1.6.1 static library")
+set(OPUSENC_INCLUDE_DIRECTORY "" CACHE PATH "Public include directory containing opusenc.h")
+set(OPUSENC_LIBRARY "" CACHE FILEPATH "Disclosed libopusenc 0.3 static library")
+set(ESPEAK_NG_DATA_DIRECTORY "" CACHE PATH "Complete generated same-revision espeak-ng-data directory")
+
+add_executable(arcane-kokoro main.cpp)
+target_compile_features(arcane-kokoro PRIVATE cxx_std_17)
+target_compile_definitions(arcane-kokoro PRIVATE LIBESPEAK_NG_EXPORT=1)
+if(WIN32)
+    target_compile_definitions(arcane-kokoro PRIVATE NOMINMAX WIN32_LEAN_AND_MEAN)
+endif()
+target_include_directories(arcane-kokoro PRIVATE
+    "${ESPEAK_NG_INCLUDE_DIRECTORY}" "${OPUS_INCLUDE_DIRECTORY}" "${OPUSENC_INCLUDE_DIRECTORY}")
+target_link_libraries(arcane-kokoro PRIVATE
+    "${ESPEAK_NG_LIBRARY}" "${UCD_LIBRARY}" "${OPUSENC_LIBRARY}" "${OPUS_LIBRARY}")
+if(MSVC)
+    target_compile_options(arcane-kokoro PRIVATE /utf-8 /EHsc)
+elseif(UNIX)
+    target_link_libraries(arcane-kokoro PRIVATE m)
+elseif(MINGW)
+    target_link_options(arcane-kokoro PRIVATE -municode)
+endif()
+install(TARGETS arcane-kokoro RUNTIME DESTINATION bin)
+if(ESPEAK_NG_DATA_DIRECTORY)
+    install(DIRECTORY "${ESPEAK_NG_DATA_DIRECTORY}/" DESTINATION share/espeak-ng-data)
+endif()
+
+if(WIN32 AND MSVC)
+    set(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION bin)
+    set(CMAKE_INSTALL_DEBUG_LIBRARIES FALSE)
+    set(CMAKE_INSTALL_DEBUG_LIBRARIES_ONLY FALSE)
+    set(CMAKE_INSTALL_UCRT_LIBRARIES FALSE)
+    set(CMAKE_INSTALL_MFC_LIBRARIES FALSE)
+    set(CMAKE_INSTALL_OPENMP_LIBRARIES FALSE)
+    include(InstallRequiredSystemLibraries)
+endif()

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

@@ -0,0 +1,249 @@
+#include <espeak-ng/speak_lib.h>
+#include <opusenc.h>
+
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <filesystem>
+#include <iostream>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#ifdef _WIN32
+#include <fcntl.h>
+#include <io.h>
+#include <windows.h>
+#endif
+
+// This private pipe uses length framing solely to transport complete text and float PCM.
+// No inference runtime is linked into this helper.
+static void send(const std::string &kind, const std::string &id, const char *data, std::size_t length) {
+    std::cout << kind << '\t' << id << '\t' << length << '\n';
+    std::size_t offset = 0;
+    while (offset < length) {
+        const auto remaining = length - offset;
+        const auto portion = remaining > static_cast<std::size_t>(std::numeric_limits<std::streamsize>::max())
+            ? std::numeric_limits<std::streamsize>::max() : static_cast<std::streamsize>(remaining);
+        std::cout.write(data + offset, portion);
+        offset += static_cast<std::size_t>(portion);
+    }
+    std::cout.flush();
+    if (!std::cout) throw std::runtime_error("Writing the complete Kokoro helper response failed.");
+}
+
+static void send(const std::string &kind, const std::string &id, const std::string &data = {}) {
+    send(kind, id, data.data(), data.length());
+}
+
+static void receive(char *data, std::size_t length) {
+    std::size_t offset = 0;
+    while (offset < length) {
+        const auto remaining = length - offset;
+        const auto portion = remaining > static_cast<std::size_t>(std::numeric_limits<std::streamsize>::max())
+            ? std::numeric_limits<std::streamsize>::max() : static_cast<std::streamsize>(remaining);
+        std::cin.read(data + offset, portion);
+        if (std::cin.gcount() != portion) throw std::runtime_error("The Kokoro command ended before its complete payload arrived.");
+        offset += static_cast<std::size_t>(portion);
+    }
+}
+
+static std::string jsonString(const std::string &text) {
+    const char *hex = "0123456789abcdef";
+    std::string result = "\"";
+    for (const unsigned char character : text) {
+        if (character == '\"' || character == '\\') {
+            result += '\\';
+            result += static_cast<char>(character);
+        } else if (character < 0x20) {
+            result += "\\u00";
+            result += hex[character >> 4];
+            result += hex[character & 15];
+        } else result += static_cast<char>(character);
+    }
+    result += '\"';
+    return result;
+}
+
+static void selectLanguage(const std::string &language) {
+    espeak_VOICE properties{};
+    properties.languages = language.c_str();
+    if (espeak_SetVoiceByProperties(&properties) != EE_OK) throw std::runtime_error("eSpeak could not select " + language + ".");
+    const espeak_VOICE *voice = espeak_GetCurrentVoice();
+    // Public languages records consist of priority, language, NUL, repeated, then NUL.
+    const char *languages = voice ? voice->languages : nullptr;
+    while (languages && *languages) {
+        ++languages;
+        if (language == languages) return;
+        languages += std::strlen(languages) + 1;
+    }
+    throw std::runtime_error("The matching eSpeak language data for " + language + " is unavailable.");
+}
+
+static void phonemize(const std::string &id, std::size_t length, const std::string &language) {
+    std::string text(length, '\0');
+    receive(text.data(), text.length());
+    if (text.find('\0') != std::string::npos) throw std::runtime_error("The public eSpeak text interface cannot consume embedded NUL characters.");
+    selectLanguage(language);
+    const void *cursor = text.c_str();
+    const char *end = text.c_str() + text.length();
+    while (cursor) {
+        const char *begin = static_cast<const char *>(cursor);
+        const char *phonemes = espeak_TextToPhonemes(&cursor, espeakCHARS_UTF8,
+            espeakPHONEMES_IPA | espeakPHONEMES_TIE | ('^' << 8));
+        if (!phonemes) throw std::runtime_error("eSpeak did not return phonemes for the current clause.");
+        // Copy the library-owned result before calling eSpeak again.
+        const std::string translated(phonemes);
+        const char *next = cursor ? static_cast<const char *>(cursor) : end;
+        if (next < begin || next > end || (cursor && next == begin)) {
+            throw std::runtime_error("eSpeak did not advance through the supplied text.");
+        }
+        const std::string consumed(begin, next);
+        send("clause", id, "{\"source\":" + jsonString(consumed) + ",\"phonemes\":" + jsonString(translated) + "}");
+    }
+    send("done", id);
+}
+
+struct EncoderOutput {
+    std::string id;
+    std::string error;
+};
+
+static int writePage(void *context, const unsigned char *data, opus_int32 length) {
+    auto &output = *static_cast<EncoderOutput *>(context);
+    try {
+        send("page", output.id, reinterpret_cast<const char *>(data), static_cast<std::size_t>(length));
+        return 0;
+    } catch (const std::exception &error) {
+        output.error = error.what();
+        return 1;
+    }
+}
+
+static int closeEncoder(void *) { return 0; }
+
+static void encodeOpus(const std::string &id, std::size_t length) {
+    if (length % sizeof(float) != 0) throw std::runtime_error("The Opus input is not complete float32 PCM framing.");
+    EncoderOutput output{id, {}};
+    const OpusEncCallbacks callbacks{writePage, closeEncoder};
+    OggOpusComments *comments = ope_comments_create();
+    if (!comments) throw std::runtime_error("Creating Opus comments failed.");
+    int error = OPE_OK;
+    OggOpusEnc *encoder = ope_encoder_create_callbacks(&callbacks, &output, comments, 24000, 1, 0, &error);
+    ope_comments_destroy(comments);
+    if (!encoder) throw std::runtime_error(ope_strerror(error));
+    try {
+        std::array<unsigned char, 4096 * 4> encoded{};
+        std::array<float, 4096> samples{};
+        std::size_t remaining = length / 4;
+        while (remaining) {
+            const auto count = remaining < samples.size() ? remaining : samples.size();
+            receive(reinterpret_cast<char *>(encoded.data()), count * 4);
+            for (std::size_t index = 0; index < count; ++index) {
+                const auto offset = index * 4;
+                const std::uint32_t bits = static_cast<std::uint32_t>(encoded[offset])
+                    | (static_cast<std::uint32_t>(encoded[offset + 1]) << 8)
+                    | (static_cast<std::uint32_t>(encoded[offset + 2]) << 16)
+                    | (static_cast<std::uint32_t>(encoded[offset + 3]) << 24);
+                std::memcpy(&samples[index], &bits, sizeof(float));
+            }
+            error = ope_encoder_write_float(encoder, samples.data(), static_cast<int>(count));
+            if (error != OPE_OK) throw std::runtime_error(ope_strerror(error));
+            remaining -= count;
+        }
+        error = ope_encoder_drain(encoder);
+        if (error != OPE_OK) throw std::runtime_error(ope_strerror(error));
+        if (!output.error.empty()) throw std::runtime_error(output.error);
+        ope_encoder_destroy(encoder);
+        encoder = nullptr;
+        send("done", id);
+    } catch (...) {
+        if (encoder) ope_encoder_destroy(encoder);
+        throw;
+    }
+}
+
+static int run(const std::vector<std::string> &arguments) {
+    std::string data;
+    if (arguments.size() == 3 && arguments[1] == "--data") data = arguments[2];
+    else throw std::runtime_error("Kokoro requires --data with the parent of the matching espeak-ng-data directory.");
+    if (espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS, 0, data.c_str(), espeakINITIALIZE_DONT_EXIT) < 0) {
+        throw std::runtime_error("Initializing the matching eSpeak language data failed.");
+    }
+    try {
+        // eSpeak may choose an environment/installed data directory when the supplied path is absent.
+        // Read its public selection so helper readiness describes the configured resources.
+        const char *selectedData = nullptr;
+        espeak_Info(&selectedData);
+        const auto expectedData = (std::filesystem::u8path(data) / "espeak-ng-data").lexically_normal();
+        if (!selectedData || std::filesystem::u8path(selectedData).lexically_normal() != expectedData) {
+            throw std::runtime_error("eSpeak selected a different data directory: " + std::string(selectedData ? selectedData : "<none>")
+                + "; requested " + expectedData.u8string());
+        }
+        // Resolve both supported dialects before reporting helper readiness.
+        selectLanguage("en-us");
+        selectLanguage("en-gb");
+        send("ready", "0");
+        std::string header;
+        while (std::getline(std::cin, header)) {
+            std::istringstream fields(header);
+            std::string kind, id, lengthText, language;
+            std::getline(fields, kind, '\t');
+            std::getline(fields, id, '\t');
+            std::getline(fields, lengthText, '\t');
+            std::getline(fields, language);
+            try {
+                const auto length = std::stoull(lengthText);
+                if (length > std::numeric_limits<std::size_t>::max()) throw std::runtime_error("The helper platform cannot represent this transport frame.");
+                if (kind == "phonemize") phonemize(id, static_cast<std::size_t>(length), language);
+                else if (kind == "opus") encodeOpus(id, static_cast<std::size_t>(length));
+                else throw std::runtime_error("Unknown Kokoro helper command: " + kind);
+            } catch (const std::exception &error) {
+                send("error", id, error.what());
+                throw;
+            }
+        }
+        if (!std::cin.eof()) throw std::runtime_error("Reading the Kokoro command stream failed.");
+        espeak_Terminate();
+        return 0;
+    } catch (...) {
+        espeak_Terminate();
+        throw;
+    }
+}
+
+#ifdef _WIN32
+static std::string utf8(const wchar_t *text) {
+    const int length = WideCharToMultiByte(CP_UTF8, 0, text, -1, nullptr, 0, nullptr, nullptr);
+    if (!length) throw std::runtime_error("Reading the Unicode Kokoro helper argument failed.");
+    std::string result(static_cast<std::size_t>(length), '\0');
+    if (!WideCharToMultiByte(CP_UTF8, 0, text, -1, result.data(), length, nullptr, nullptr)) {
+        throw std::runtime_error("Converting the Unicode Kokoro helper argument failed.");
+    }
+    result.pop_back();
+    return result;
+}
+
+int wmain(int argc, wchar_t **argv) {
+    _setmode(_fileno(stdin), _O_BINARY);
+    _setmode(_fileno(stdout), _O_BINARY);
+#else
+int main(int argc, char **argv) {
+#endif
+    try {
+        std::vector<std::string> arguments;
+        for (int index = 0; index < argc; ++index) {
+#ifdef _WIN32
+            arguments.push_back(utf8(argv[index]));
+#else
+            arguments.emplace_back(argv[index]);
+#endif
+        }
+        return run(arguments);
+    } catch (const std::exception &error) {
+        std::cerr << error.what() << '\n';
+        return 1;
+    }
+}

package/src/local-ai/magpie/build.mjs

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {mkdir} from 'node:fs/promises';
+import Is from 'strong-type';
+import {runProcess} from '../../process.mjs';
+
+const is = new Is(false);
+
+/** Build the first-party adapter against an explicitly prepared NeMo TTS runtime. */
+export async function buildMagpieHelper({runtime, outputRoot, signal, onEvent} = {}) {
+    if (!is.string(runtime?.cmakeDirectory) || !is.string(outputRoot)) {
+        throw new TypeError('Magpie requires the selected NeMo runtime cmakeDirectory and helper outputRoot.');
+    }
+    const root = path.resolve(outputRoot);
+    const build = path.join(root, 'build');
+    const source = fileURLToPath(new URL('./native/', import.meta.url));
+    await mkdir(root, {recursive: true});
+    const options = {signal, onEvent};
+    const configure = await runProcess(
+        'cmake',
+        ['-S', source, '-B', build, `-DNeMoSpeech_DIR=${path.resolve(runtime.cmakeDirectory)}`,
+            `-DCMAKE_INSTALL_PREFIX=${root}`, '-DCMAKE_BUILD_TYPE=Release'],
+        options
+    );
+    const compile = await runProcess('cmake', ['--build', build, '--config', 'Release'], options);
+    const install = await runProcess('cmake', ['--install', build, '--config', 'Release'], options);
+    return {
+        platform: process.platform,
+        architecture: process.arch,
+        root,
+        helperExecutable: path.join(root, 'bin', process.platform === 'win32' ? 'arcane-magpie.exe' : 'arcane-magpie'),
+        diagnostics: {configure, compile, install}
+    };
+}
+
+export default buildMagpieHelper;

package/src/local-ai/magpie/helper.mjs

@@ -0,0 +1,254 @@
+import path from 'node:path';
+import {PassThrough} from 'node:stream';
+import Is from 'strong-type';
+import {runProcess} from '../../process.mjs';
+
+const is = new Is(false);
+
+/** One retained native synthesizer; the host owns playback and audio devices. */
+export function createMagpieHelper({runtime, paths, speaker, executionTarget, onEvent}) {
+    const input = new PassThrough();
+    const lifetime = new AbortController();
+    const readiness = deferred();
+    let sequence = 0;
+    let pending = null;
+    let metadata = null;
+    let fragment = Buffer.alloc(0);
+    let frame = null;
+    let writes = Promise.resolve();
+    let stopping = false;
+    let exited = false;
+    let terminalError = null;
+    let closing = null;
+    const env = {...process.env};
+    const directory = runtime.libraryDirectory ?? path.dirname(runtime.helperExecutable);
+    const variable = process.platform === 'win32'
+        ? Object.keys(env).find(function pathVariable(name) { return name.toLowerCase() === 'path'; }) ?? 'PATH'
+        : process.platform === 'darwin' ? 'DYLD_LIBRARY_PATH' : 'LD_LIBRARY_PATH';
+    env[variable] = [directory, env[variable]].filter(Boolean).join(path.delimiter);
+    // The native device owner supplies the selected CUDA UUID/visible device.
+    // This adapter neither invents a device ordinal nor retries on another device.
+    if (executionTarget.cudaVisibleDevices !== undefined) {
+        env.CUDA_VISIBLE_DEVICES = executionTarget.cudaVisibleDevices;
+    }
+    const iterator = input[Symbol.asyncIterator]();
+    const incoming = {
+        [Symbol.asyncIterator]() { return this; },
+        next() { return iterator.next(); },
+        return() { input.end(); return iterator.return(); }
+    };
+    const completion = runProcess(
+        runtime.helperExecutable,
+        [paths.model, paths.codec, paths.tokenizerDirectory, String(speaker), executionTarget.backend],
+        {
+            env, signal: lifetime.signal, input: incoming, onEvent,
+            outputEncoding: {stdout: null, stderr: 'utf8'},
+            captureOutput: {stdout: false, stderr: true},
+            emitOutputEvents: {stdout: false, stderr: true},
+            onOutput: receive
+        }
+    ).then(function processExited(result) {
+        if (fragment.length || frame) throw failure('MAGPIE_PROTOCOL_INCOMPLETE', 'The Magpie helper exited during an output frame.');
+        if (!stopping || (pending && !pending.terminal)) throw failure('MAGPIE_HELPER_EXITED', 'The Magpie helper exited before its work completed.', result);
+        return result;
+    }).catch(function processFailed(error) {
+        terminalError = error;
+        throw error;
+    }).finally(function processSettled() {
+        exited = true;
+        input.end();
+        const error = terminalError ?? failure('MAGPIE_HELPER_CLOSED', 'The Magpie helper has closed.');
+        readiness.reject(error);
+        pending?.response.reject(error);
+    });
+    completion.catch(function observeProcessFailure() {});
+
+    async function receive({stream, chunk}) {
+        if (stream !== 'stdout') return;
+        fragment = fragment.length ? Buffer.concat([fragment, chunk]) : chunk;
+        for (;;) {
+            if (!frame) {
+                const boundary = fragment.indexOf(10);
+                if (boundary < 0) return;
+                const [kind, id, encodedLength] = fragment.subarray(0, boundary).toString('utf8').split('\t');
+                const length = Number(encodedLength);
+                if (!is.safeInteger(length) || length < 0) {
+                    throw failure('MAGPIE_PROTOCOL_UNREADABLE', 'The Magpie helper returned unreadable transport framing.');
+                }
+                frame = {kind, id, length};
+                fragment = fragment.subarray(boundary + 1);
+            }
+            if (fragment.length < frame.length) return;
+            const payload = fragment.subarray(0, frame.length);
+            fragment = fragment.subarray(frame.length);
+            const record = frame;
+            frame = null;
+            if (record.kind === 'fatal') {
+                throw failure('MAGPIE_NATIVE_FAILED', payload.toString('utf8'));
+            }
+            if (record.kind === 'ready') {
+                const sampleRate = Number(payload.toString('utf8'));
+                if (!is.integer(sampleRate) || sampleRate <= 0) {
+                    throw failure('MAGPIE_PROTOCOL_UNREADABLE', 'The native synthesizer returned an unreadable sample rate.');
+                }
+                metadata = {sampleRate, channels: 1, format: 's16le'};
+                readiness.resolve(metadata);
+                continue;
+            }
+            const operation = pending;
+            if (!operation || record.id !== operation.id) {
+                throw failure('MAGPIE_PROTOCOL_UNKNOWN_REQUEST', `The Magpie helper returned ${record.kind} without its active request.`);
+            }
+            if (record.kind === 'audio' || record.kind === 'started') {
+                if (operation.signal?.aborted || operation.callbackError) continue;
+                try {
+                    if (record.kind === 'audio') {
+                        // Awaited delivery lets runProcess pause stdout and native PCM production.
+                        await operation.onAudio({pcm: Buffer.from(payload), ...metadata});
+                    } else {
+                        await operation.onProgress?.({phase: 'synthesizing'});
+                    }
+                } catch (error) {
+                    operation.callbackError = error;
+                    try { await writeCommand([Buffer.from(`stop\t${operation.id}\n`)]); }
+                    catch (stopError) {
+                        throw new AggregateError([error, stopError], 'The Magpie consumer and native cancellation failed.');
+                    }
+                }
+            } else if (record.kind === 'error') {
+                operation.terminal = true;
+                const nativeError = failure('MAGPIE_NATIVE_FAILED', payload.toString('utf8'));
+                const previous = operation.callbackError ?? operation.signal?.reason;
+                operation.response.reject(previous
+                    ? new AggregateError([previous, nativeError], 'Magpie synthesis and its consumer failed.') : nativeError);
+            } else if (record.kind === 'cancelled') {
+                operation.terminal = true;
+                operation.response.reject(operation.callbackError ?? operation.signal?.reason
+                    ?? failure('MAGPIE_SYNTHESIS_CANCELLED', 'The native synthesizer cancelled this utterance.'));
+            } else if (record.kind === 'done') {
+                operation.terminal = true;
+                if (operation.callbackError) operation.response.reject(operation.callbackError);
+                else if (operation.signal?.aborted) operation.response.reject(operation.signal.reason);
+                else operation.response.resolve(metadata);
+            } else {
+                throw failure('MAGPIE_PROTOCOL_UNREADABLE', `The Magpie helper returned an unknown record ${record.kind}.`);
+            }
+        }
+    }
+
+    function writeCommand(parts) {
+        const writing = writes.then(async function writeFramedCommand() {
+            if (exited || lifetime.signal.aborted) throw terminalError ?? lifetime.signal.reason
+                ?? failure('MAGPIE_HELPER_CLOSED', 'The Magpie helper has closed.');
+            for (const part of parts) {
+                await new Promise(function writeInput(resolve, reject) {
+                    input.write(part, function inputWritten(error) {
+                        if (error) reject(error);
+                        else resolve();
+                    });
+                });
+            }
+        });
+        writes = writing.catch(function commandFailed(error) {
+            // Incomplete framing cannot be reused. Retire only this owned process.
+            terminalError = error;
+            stopping = true;
+            lifetime.abort(error);
+        });
+        return writing;
+    }
+
+    async function synthesize({text, languageCode, speaker: selectedSpeaker}, {signal, onAudio, onProgress} = {}) {
+        signal?.throwIfAborted();
+        await readiness.promise;
+        signal?.throwIfAborted();
+        if (stopping || exited || pending) {
+            throw terminalError ?? failure('MAGPIE_HELPER_UNAVAILABLE', 'The Magpie helper is unavailable for another utterance.');
+        }
+        const operation = {
+            id: String(++sequence), response: deferred(), signal, onAudio, onProgress, callbackError: null, terminal: false
+        };
+        pending = operation;
+        function stopUtterance() {
+            writeCommand([Buffer.from(`stop\t${operation.id}\n`)]).catch(function stopFailed(error) {
+                terminalError = error;
+            });
+        }
+        const language = Buffer.from(languageCode, 'utf8');
+        const content = Buffer.from(text, 'utf8');
+        try {
+            // Install cancellation after enqueueing the complete text frame, so a
+            // concurrent stop cannot precede its own native synthesis command.
+            const writing = writeCommand([
+                Buffer.from(`synthesize\t${operation.id}\t${selectedSpeaker}\t${language.length}\t${content.length}\n`),
+                language, content
+            ]);
+            signal?.addEventListener('abort', stopUtterance, {once: true});
+            if (signal?.aborted) stopUtterance();
+            await writing;
+            return await operation.response.promise;
+        } catch (error) {
+            if (lifetime.signal.aborted || exited) {
+                try { await completion; }
+                catch (processError) {
+                    if (processError !== error) throw new AggregateError([error, processError], 'Magpie synthesis and process cleanup failed.');
+                }
+            }
+            throw error;
+        } finally {
+            signal?.removeEventListener('abort', stopUtterance);
+            if (pending === operation) pending = null;
+        }
+    }
+
+    function close() {
+        if (closing) return closing;
+        stopping = true;
+        closing = Promise.resolve().then(async function closeHelper() {
+            if (!exited) {
+                if (!metadata) {
+                    // No C-ABI cancellation exists during model creation.
+                    lifetime.abort(failure('MAGPIE_LOADING_CANCELLED', 'The Magpie model load was cancelled.'));
+                } else {
+                    await writeCommand([Buffer.from('close\t0\n')]);
+                    input.end();
+                }
+            }
+            try { await completion; }
+            catch (error) {
+                if (!expectedCancellation(error, lifetime.signal)) throw error;
+            }
+        });
+        return closing;
+    }
+
+    return {
+        ready: readiness.promise, completion, synthesize, close,
+        get exited() { return exited; }
+    };
+}
+
+function deferred() {
+    const value = {};
+    value.promise = new Promise(function awaitResponse(resolve, reject) {
+        value.resolve = resolve;
+        value.reject = reject;
+    });
+    value.promise.catch(function observePendingFailure() {});
+    return value;
+}
+
+function failure(code, message, data) {
+    const error = new Error(message);
+    error.code = code;
+    if (data !== undefined) error.data = data;
+    return error;
+}
+
+function expectedCancellation(error, signal) {
+    if (!signal.aborted) return false;
+    if (error === signal.reason) return true;
+    if (!['ARCANE_CANCELLED', 'ABORT_ERR'].includes(error?.code) && error?.name !== 'AbortError') return false;
+    if (is.array(error.errors) && !error.errors.every(function cancelled(cause) { return expectedCancellation(cause, signal); })) return false;
+    return error.cause !== undefined && expectedCancellation(error.cause, signal);
+}