arcane-os 0.94.0 → 0.96.0

package/src/core/services/speech.mjs

@@ -42,7 +42,7 @@ function waitForLoad(task, signal) {
 }
 
 /** Hosts supply selected engines; this service owns their independent lifetimes. */
-export function createSpeechService({stt, tts, signal} = {}) {
+export function createSpeechService({stt, tts, signal, autoLoad = true} = {}) {
     const roles = {
         stt: {engine: stt, operation: 'transcribe', state: null, loading: null, changing: null, unsubscribe: null},
         tts: {engine: tts, operation: 'synthesize', state: null, loading: null, changing: null, unsubscribe: null}
@@ -68,6 +68,8 @@ export function createSpeechService({stt, tts, signal} = {}) {
         {source: 'core-speech', eventTypes: ['speech.state']}
     );
     const jobs = new Set();
+    const streams = new Map();
+    const syntheses = new Map();
     const publications = [];
     let context;
     let started = false;
@@ -91,8 +93,10 @@ export function createSpeechService({stt, tts, signal} = {}) {
             ttsEngine: roles.tts.state.providerId ?? '',
             sttEngine: roles.stt.state.providerId ?? '',
             roles: {
-                stt: {...roles.stt.state, available: transcriptionAvailable},
-                tts: {...roles.tts.state, available: synthesisAvailable}
+                stt: {...roles.stt.state, available: transcriptionAvailable,
+                    supportsStreaming: is.function(roles.stt.engine?.openStream)},
+                tts: {...roles.tts.state, available: synthesisAvailable,
+                    supportsStreaming: is.function(roles.tts.engine?.synthesizeStream)}
             },
             closed
         };
@@ -173,7 +177,7 @@ export function createSpeechService({stt, tts, signal} = {}) {
             return;
         }
         // Replay can synchronously select an activation or close the service.
-        if (role.changing || closing || closed) return;
+        if (role.changing || closing || closed || autoLoad === false) return;
         const task = Promise.resolve().then(
             async function loadSpeechEngine() {
                 lifetimeSignal.throwIfAborted();
@@ -285,6 +289,201 @@ export function createSpeechService({stt, tts, signal} = {}) {
         }
     }
 
+    function streamRole(name, operation, request, streamId) {
+        if (closing || closed) throw failure('CORE_CLOSING', 'The speech service is closing.');
+        const role = roles[name];
+        if (!is.function(role.engine?.[operation])) {
+            throw failure('SPEECH_OPERATION_UNAVAILABLE', `The ${name} speech engine does not support ${operation}().`);
+        }
+        const operationSignal = request.signal
+            ? AbortSignal.any([lifetimeSignal, request.signal]) : lifetimeSignal;
+        operationSignal.throwIfAborted();
+        request.emit?.('speech.progress', {
+            streamId, requestId: request.requestId, role: name, status: 'Thinking', progress: {phase: 'accepted'}
+        });
+        return {role, operationSignal};
+    }
+
+    function retainStreamTask(task) {
+        jobs.add(task);
+        function releaseSpeechStreamTask() { jobs.delete(task); }
+        task.then(releaseSpeechStreamTask, releaseSpeechStreamTask);
+        return task;
+    }
+
+    function openStream({streamId, options = {}} = {}, request) {
+        const activation = streamRole('stt', 'openStream', request, streamId);
+        const role = activation.role;
+        const controller = new AbortController();
+        const operationSignal = AbortSignal.any([activation.operationSignal, controller.signal]);
+        if (!is.string(streamId) || !streamId) throw new TypeError('A speech stream requires a streamId.');
+        if (streams.has(streamId)) throw failure('SPEECH_STREAM_ACTIVE', 'The speech stream is already open.');
+        const record = {stream: null, controller, queue: Promise.resolve(), ending: false, cancellation: null, task: null};
+        streams.set(streamId, record);
+
+        function cancelNativeStream() {
+            record.ending = true;
+            if (record.stream && !record.cancellation) {
+                record.cancellation = Promise.resolve().then(function cancelOwnedNativeStream() {
+                    return record.stream.cancel();
+                });
+            }
+            return record.cancellation;
+        }
+        function abortedStream() {
+            cancelNativeStream()?.catch(function reportNativeStreamCancellation(error) {
+                console.error('Native speech stream cancellation failed.', error);
+            });
+        }
+        record.cancel = cancelNativeStream;
+        operationSignal.addEventListener('abort', abortedStream, {once: true});
+        const task = (async function ownTranscriptionStream() {
+            try {
+                if (role.loading) await waitForLoad(role.loading, operationSignal);
+                operationSignal.throwIfAborted();
+                record.stream = await role.engine.openStream({
+                    ...options,
+                    signal: operationSignal,
+                    onUpdate: function reportTranscriptionUpdate(result) {
+                        if (!operationSignal.aborted) request.emit?.('speech.transcription', {streamId, result});
+                    }
+                });
+                if (operationSignal.aborted) {
+                    await cancelNativeStream();
+                    operationSignal.throwIfAborted();
+                }
+                request.emit?.('speech.opened', {
+                    streamId,
+                    ...(options.sampleRate === undefined ? {} : {sampleRate: options.sampleRate})
+                });
+                const result = await record.stream.completion;
+                operationSignal.throwIfAborted();
+                return result;
+            } catch (error) {
+                try { await cancelNativeStream(); } catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], 'Speech stream and cleanup failed.');
+                }
+                throw error;
+            } finally {
+                operationSignal.removeEventListener('abort', abortedStream);
+                if (streams.get(streamId) === record) streams.delete(streamId);
+            }
+        })();
+        record.task = task;
+        return retainStreamTask(task);
+    }
+
+    function streamOperation(operation, {streamId, audio} = {}, request) {
+        request.signal?.throwIfAborted();
+        const record = streams.get(streamId);
+        if (operation === 'cancel') {
+            if (!record) return {streamId, cancelled: true};
+            record.controller.abort();
+            return record.task.then(
+                function streamFinishedBeforeCancellation() { return {streamId, cancelled: true}; },
+                function streamCancellationSettled(error) {
+                    if (error?.name !== 'AbortError') throw error;
+                    return {streamId, cancelled: true};
+                }
+            );
+        }
+        if (!record?.stream) throw failure('SPEECH_STREAM_UNAVAILABLE', 'The speech stream is not open.');
+        if (record.ending) throw failure('SPEECH_STREAM_ENDING', 'The speech stream is finishing.');
+        if (operation === 'finish') record.ending = true;
+        const task = record.queue.then(function performSpeechStreamOperation() {
+            request.signal?.throwIfAborted();
+            if (operation === 'push') return record.stream.push(decodeFloatAudio(audio));
+            return record.stream[operation]();
+        });
+        record.queue = task;
+        task.catch(function cancelFailedStreamOperation() {
+            record.cancel()?.catch(function reportStreamOperationCleanup(error) {
+                console.error('Failed speech stream cleanup failed.', error);
+            });
+        });
+        return retainStreamTask(task);
+    }
+
+    function synthesizeStream({streamId, request: payload} = {}, request) {
+        const activation = streamRole('tts', 'synthesizeStream', request, streamId);
+        const role = activation.role;
+        const controller = new AbortController();
+        const operationSignal = AbortSignal.any([activation.operationSignal, controller.signal]);
+        if (!is.string(streamId) || !streamId) throw new TypeError('Speech synthesis requires a streamId.');
+        if (syntheses.has(streamId)) throw failure('SPEECH_STREAM_ACTIVE', 'The speech synthesis is already active.');
+        const record = {controller, task: null, sequence: 0, acknowledgements: new Map()};
+        syntheses.set(streamId, record);
+        function cancelAudioDelivery() {
+            for (const acknowledgement of record.acknowledgements.values()) acknowledgement.reject(operationSignal.reason);
+            record.acknowledgements.clear();
+        }
+        operationSignal.addEventListener('abort', cancelAudioDelivery, {once: true});
+        const task = (async function ownSynthesisStream() {
+            try {
+                if (role.loading) await waitForLoad(role.loading, operationSignal);
+                operationSignal.throwIfAborted();
+                const result = await role.engine.synthesizeStream(payload, {
+                    signal: operationSignal,
+                    requestId: request.requestId,
+                    onProgress: function reportSynthesisProgress(progress) {
+                        if (!operationSignal.aborted) request.emit?.('speech.progress', {
+                            streamId, requestId: request.requestId, role: 'tts', status: 'Thinking', progress
+                        });
+                    },
+                    onAudio: async function reportSynthesisAudio(audio) {
+                        operationSignal.throwIfAborted();
+                        const sequence = ++record.sequence;
+                        const consumed = new Promise(function waitForAudioConsumer(resolve, reject) {
+                            record.acknowledgements.set(sequence, {resolve, reject});
+                        });
+                        // The native producer waits here, never the event parser.
+                        // Cancellation releases this wait before joining native work.
+                        try {
+                            const pcm = audio.pcm;
+                            const encoded = Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+                            request.emit?.('speech.audio', {
+                                streamId, sequence,
+                                audio: {...audio, pcm: {encoding: 'base64', data: encoded.toString('base64')}}
+                            });
+                            await consumed;
+                            operationSignal.throwIfAborted();
+                        } finally {
+                            record.acknowledgements.delete(sequence);
+                        }
+                    }
+                });
+                operationSignal.throwIfAborted();
+                return result;
+            } finally {
+                operationSignal.removeEventListener('abort', cancelAudioDelivery);
+                if (syntheses.get(streamId) === record) syntheses.delete(streamId);
+            }
+        })();
+        record.task = task;
+        return retainStreamTask(task);
+    }
+
+    function synthesisControl(operation, {streamId, sequence} = {}, request) {
+        request.signal?.throwIfAborted();
+        const record = syntheses.get(streamId);
+        if (operation === 'cancel') {
+            if (!record) return {streamId, cancelled: true};
+            record.controller.abort();
+            return record.task.then(
+                function synthesisFinishedBeforeCancellation() { return {streamId, cancelled: true}; },
+                function synthesisCancellationSettled(error) {
+                    if (error !== record.controller.signal.reason) throw error;
+                    return {streamId, cancelled: true};
+                }
+            );
+        }
+        const acknowledgement = record?.acknowledgements.get(sequence);
+        if (!acknowledgement) throw failure('SPEECH_AUDIO_UNAVAILABLE', 'That speech audio contribution is not awaiting consumption.');
+        record.acknowledgements.delete(sequence);
+        acknowledgement.resolve();
+        return {streamId, sequence};
+    }
+
     function subscribe(listener, {replay = true, signal: subscriptionSignal} = {}) {
         if (!is.function(listener)) {
             throw new TypeError('A speech state listener must be a function.');
@@ -407,6 +606,28 @@ export function createSpeechService({stt, tts, signal} = {}) {
             },
             'speech.synthesize': function synthesize(parameters, request = {}) {
                 return invoke('tts', parameters, request);
+            },
+            // The open call stays pending so normal connection cancellation owns
+            // the native stream; controls never extend it to service lifetime.
+            'speech.open': openStream,
+            'speech.push': function push(parameters, request) {
+                return streamOperation('push', parameters, request);
+            },
+            'speech.endpoint': function endpoint(parameters, request) {
+                return streamOperation('forceEndpoint', parameters, request);
+            },
+            'speech.finish': function finish(parameters, request) {
+                return streamOperation('finish', parameters, request);
+            },
+            'speech.cancel': function cancel(parameters, request) {
+                return streamOperation('cancel', parameters, request);
+            },
+            'speech.synthesizeStream': synthesizeStream,
+            'speech.audioConsumed': function audioConsumed(parameters, request) {
+                return synthesisControl('consumed', parameters, request);
+            },
+            'speech.cancelSynthesis': function cancelSynthesis(parameters, request) {
+                return synthesisControl('cancel', parameters, request);
             }
         },
         drain: close,
@@ -420,4 +641,16 @@ export function createSpeechService({stt, tts, signal} = {}) {
     };
 }
 
+function decodeFloatAudio(audio) {
+    if (audio?.encoding !== 'f32le' || !is.string(audio.data)) {
+        throw new TypeError('Core streaming audio requires {encoding: "f32le", data: BASE64}.');
+    }
+    const encoded = Buffer.from(audio.data, 'base64');
+    if (encoded.length % 4 !== 0) throw new TypeError('The f32le transport ends during a sample.');
+    const samples = new Float32Array(encoded.length / 4);
+    const bits = new Uint32Array(samples.buffer);
+    for (let index = 0; index < samples.length; index += 1) bits[index] = encoded.readUInt32LE(index * 4);
+    return samples;
+}
+
 export default createSpeechService;

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);
+}