arcane-os 0.94.0 → 0.96.0

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

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.26)
+project(ArcaneNemotron LANGUAGES CXX)
+
+find_package(NeMoSpeech REQUIRED COMPONENTS ASR)
+
+add_executable(arcane-nemotron main.cpp)
+target_compile_features(arcane-nemotron PRIVATE cxx_std_17)
+target_link_libraries(arcane-nemotron PRIVATE NeMoSpeech::ASR)
+if(MSVC)
+    target_compile_options(arcane-nemotron PRIVATE /utf-8 /EHsc)
+endif()
+if(APPLE)
+    set_target_properties(arcane-nemotron PROPERTIES INSTALL_RPATH "@loader_path;@loader_path/../lib")
+elseif(UNIX)
+    set_target_properties(arcane-nemotron PROPERTIES INSTALL_RPATH "$ORIGIN;$ORIGIN/../lib")
+endif()
+install(TARGETS arcane-nemotron RUNTIME DESTINATION bin)

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

@@ -0,0 +1,282 @@
+#include <nemo_speech/asr.h>
+
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <locale>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#ifdef _WIN32
+#include <fcntl.h>
+#include <io.h>
+#include <windows.h>
+#endif
+
+namespace {
+
+using Recognizer = std::unique_ptr<nemo_speech_asr_recognizer, decltype(&nemo_speech_asr_destroy)>;
+using Stream = std::unique_ptr<nemo_speech_asr_stream, decltype(&nemo_speech_asr_stream_close)>;
+using Result = std::unique_ptr<nemo_speech_asr_result, decltype(&nemo_speech_asr_result_destroy)>;
+
+void check(nemo_speech_asr_status status) {
+    if (status != NEMO_SPEECH_ASR_OK) {
+        const char* message = nemo_speech_asr_last_error();
+        throw std::runtime_error(message ? message : "The native ASR operation failed.");
+    }
+}
+
+std::string json_string(const char* value) {
+    std::ostringstream output;
+    output << '"';
+    if (value) {
+        for (const unsigned char character : std::string(value)) {
+            switch (character) {
+                case '"': output << "\\\""; break;
+                case '\\': output << "\\\\"; break;
+                case '\n': output << "\\n"; break;
+                case '\r': output << "\\r"; break;
+                case '\t': output << "\\t"; break;
+                default:
+                    if (character < 0x20) {
+                        output << "\\u" << std::hex << std::setw(4) << std::setfill('0')
+                               << static_cast<unsigned int>(character) << std::dec;
+                    } else {
+                        output << character;
+                    }
+            }
+        }
+    }
+    output << '"';
+    return output.str();
+}
+
+void emit_error(uint64_t request, const std::string& message) {
+    std::cout << "{\"request\":" << request << ",\"error\":" << json_string(message.c_str())
+              << "}\n" << std::flush;
+}
+
+void emit_ack(uint64_t request) {
+    std::cout << "{\"request\":" << request << ",\"ok\":true}\n" << std::flush;
+}
+
+void emit_running(uint64_t request) {
+    std::cout << "{\"request\":" << request << ",\"running\":true}\n" << std::flush;
+}
+
+std::string read_text(size_t count) {
+    std::string text(count, '\0');
+    if (count && !std::cin.read(text.data(), count)) {
+        throw std::runtime_error("Nemotron input ended during a language field.");
+    }
+    return text;
+}
+
+std::vector<float> read_audio(size_t samples) {
+    std::vector<float> audio(samples);
+    std::vector<unsigned char> encoded(samples * sizeof(float));
+    if (!encoded.empty() && !std::cin.read(reinterpret_cast<char*>(encoded.data()), encoded.size())) {
+        throw std::runtime_error("Nemotron input ended during a float32 audio frame.");
+    }
+    for (size_t index = 0; index < samples; ++index) {
+        const auto* value = encoded.data() + index * sizeof(float);
+        const uint32_t bits = static_cast<uint32_t>(value[0])
+            | (static_cast<uint32_t>(value[1]) << 8)
+            | (static_cast<uint32_t>(value[2]) << 16)
+            | (static_cast<uint32_t>(value[3]) << 24);
+        std::memcpy(&audio[index], &bits, sizeof(float));
+    }
+    return audio;
+}
+
+void emit_result(uint64_t request, uint64_t sequence, const nemo_speech_asr_result* result) {
+    std::ostringstream output;
+    output.imbue(std::locale::classic());
+    output << std::setprecision(std::numeric_limits<float>::max_digits10);
+    output << "{\"request\":" << request << ",\"update\":{\"sequence\":" << sequence
+           << ",\"final\":" << (nemo_speech_asr_result_is_final(result) ? "true" : "false")
+           << ",\"audioProcessedSeconds\":" << nemo_speech_asr_result_audio_processed(result)
+           << ",\"channelTag\":" << nemo_speech_asr_result_channel_tag(result)
+           << ",\"alternatives\":[";
+    const size_t alternatives = nemo_speech_asr_result_alternative_count(result);
+    for (size_t alternative = 0; alternative < alternatives; ++alternative) {
+        if (alternative) output << ',';
+        output << "{\"text\":" << json_string(nemo_speech_asr_result_transcript(result, alternative))
+               << ",\"confidence\":" << nemo_speech_asr_result_confidence(result, alternative)
+               << ",\"words\":[";
+        const size_t words = nemo_speech_asr_result_word_count(result, alternative);
+        for (size_t index = 0; index < words; ++index) {
+            if (index) output << ',';
+            output << "{\"word\":" << json_string(nemo_speech_asr_result_word_text(result, alternative, index))
+                   << ",\"startTimeMs\":" << nemo_speech_asr_result_word_start_time(result, alternative, index)
+                   << ",\"endTimeMs\":" << nemo_speech_asr_result_word_end_time(result, alternative, index)
+                   << ",\"confidence\":" << nemo_speech_asr_result_word_confidence(result, alternative, index)
+                   << ",\"speaker\":" << nemo_speech_asr_result_word_speaker_tag(result, alternative, index) << '}';
+        }
+        output << "],\"languageCodes\":[";
+        const size_t languages = nemo_speech_asr_result_language_count(result, alternative);
+        for (size_t index = 0; index < languages; ++index) {
+            if (index) output << ',';
+            output << json_string(nemo_speech_asr_result_language_code(result, alternative, index));
+        }
+        output << "]}";
+    }
+    output << "]}}\n";
+    // A complete result is emitted before asking for the next one. An error
+    // later in the drain cannot erase earlier native results.
+    std::cout << output.str() << std::flush;
+}
+
+void drain(uint64_t request, nemo_speech_asr_stream* stream, uint64_t& sequence) {
+    while (true) {
+        nemo_speech_asr_result* raw = nullptr;
+        const auto status = nemo_speech_asr_stream_next(stream, &raw);
+        const Result result(raw, nemo_speech_asr_result_destroy);
+        check(status);
+        if (!result) return;
+        emit_result(request, ++sequence, result.get());
+    }
+}
+
+int serve(const std::string& model_path, const std::string& diarization_path, int gpu) {
+#ifdef _WIN32
+    _setmode(_fileno(stdin), _O_BINARY);
+    _setmode(_fileno(stdout), _O_BINARY);
+#endif
+    nemo_speech_asr_backend_config backend{};
+    backend.size = sizeof(backend);
+    backend.gpu = gpu;
+    nemo_speech_asr_model_config model{};
+    model.size = sizeof(model);
+    model.path = model_path.c_str();
+    nemo_speech_asr_diar_config diarization{};
+    diarization.size = sizeof(diarization);
+    diarization.model_path = diarization_path.empty() ? nullptr : diarization_path.c_str();
+    diarization.left_context_frames = -1;
+    nemo_speech_asr_endpointing_config endpointing{};
+    endpointing.size = sizeof(endpointing);
+    endpointing.enable = false;
+    nemo_speech_asr_recognizer_config configuration{};
+    configuration.size = sizeof(configuration);
+    configuration.backend = &backend;
+    configuration.model = &model;
+    configuration.diar = &diarization;
+    configuration.endpointing = &endpointing;
+    nemo_speech_asr_recognizer* raw_recognizer = nullptr;
+    const auto status = nemo_speech_asr_create(&configuration, &raw_recognizer);
+    const Recognizer recognizer(raw_recognizer, nemo_speech_asr_destroy);
+    check(status);
+    // The stream is destroyed before its recognizer. All stream calls stay on
+    // this thread; the host owns capture, timing and conversational decisions.
+    Stream stream(nullptr, nemo_speech_asr_stream_close);
+    int sample_rate = 16000;
+    uint64_t sequence = 0;
+    std::string language;
+    std::cout << "{\"ready\":true,\"version\":" << json_string(nemo_speech_asr_version())
+              << ",\"requestedGpu\":" << gpu << "}\n" << std::flush;
+    std::string line;
+    while (std::getline(std::cin, line)) {
+        uint64_t request = 0;
+        std::string operation;
+        std::istringstream command(line);
+        if (!(command >> operation >> request)) {
+            emit_error(0, "Unreadable Nemotron command.");
+            return 1;
+        }
+        try {
+            if (operation == "open") {
+                size_t language_length = 0;
+                int requested_rate = 0;
+                if (!(command >> requested_rate >> language_length)) {
+                    throw std::runtime_error("Unreadable Nemotron stream configuration.");
+                }
+                const std::string requested_language = read_text(language_length);
+                if (stream) throw std::runtime_error("A Nemotron stream is already open.");
+                language = requested_language;
+                sample_rate = requested_rate;
+                auto options = nemo_speech_asr_recognition_options_default();
+                options.language_code = language.empty() ? nullptr : language.c_str();
+                options.interim_results = true;
+                options.enable_word_time_offsets = true;
+                options.enable_speaker_diarization = !diarization_path.empty();
+                options.enable_automatic_punctuation = false;
+                options.profanity_filter = false;
+                options.verbatim_transcripts = true;
+                nemo_speech_asr_stream* raw_stream = nullptr;
+                emit_running(request);
+                const auto opened = nemo_speech_asr_streaming_recognize(recognizer.get(), &options, &raw_stream);
+                stream.reset(raw_stream);
+                check(opened);
+                sequence = 0;
+            } else if (operation == "close") {
+                stream.reset();
+            } else {
+                std::vector<float> audio;
+                if (operation == "push") {
+                    size_t samples = 0;
+                    if (!(command >> samples)) throw std::runtime_error("Unreadable Nemotron audio frame.");
+                    audio = read_audio(samples);
+                }
+                if (!stream) throw std::runtime_error("No Nemotron stream is open.");
+                emit_running(request);
+                if (operation == "push") {
+                    check(nemo_speech_asr_stream_push_f32(stream.get(), audio.data(), audio.size(), sample_rate));
+                } else if (operation == "endpoint") {
+                    check(nemo_speech_asr_stream_force_endpoint(stream.get()));
+                } else if (operation == "finish") {
+                    check(nemo_speech_asr_stream_finish(stream.get()));
+                } else {
+                    throw std::runtime_error("Unknown Nemotron operation.");
+                }
+                drain(request, stream.get(), sequence);
+                if (operation == "finish") stream.reset();
+            }
+            emit_ack(request);
+        } catch (const std::exception& error) {
+            emit_error(request, error.what());
+            if (!std::cin) return 1;
+        }
+    }
+    return 0;
+}
+
+int run(const std::vector<std::string>& arguments) {
+    try {
+        if (arguments.size() != 4) {
+            throw std::runtime_error("Usage: arcane-nemotron ASR.gguf DIARIZATION.gguf GPU_ORDINAL (-1 selects CPU).");
+        }
+        return serve(arguments[1], arguments[2], std::stoi(arguments[3]));
+    } catch (const std::exception& error) {
+        emit_error(0, error.what());
+        return 1;
+    }
+}
+
+} // namespace
+
+#ifdef _WIN32
+int wmain(int argc, wchar_t** argv) {
+    std::vector<std::string> arguments;
+    for (int index = 0; index < argc; ++index) {
+        const int length = WideCharToMultiByte(CP_UTF8, 0, argv[index], -1, nullptr, 0, nullptr, nullptr);
+        if (length == 0) {
+            emit_error(0, "Windows could not encode a Nemotron argument as UTF-8.");
+            return 1;
+        }
+        std::string argument(length, '\0');
+        WideCharToMultiByte(CP_UTF8, 0, argv[index], -1, argument.data(), length, nullptr, nullptr);
+        argument.pop_back();
+        arguments.push_back(argument);
+    }
+    return run(arguments);
+}
+#else
+int main(int argc, char** argv) {
+    return run(std::vector<std::string>(argv, argv + argc));
+}
+#endif

package/src/native/macos-provider.mjs

@@ -7,6 +7,8 @@ import Is from 'strong-type';
 import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
 import {runProcess} from '../process.mjs';
 import {createPortableNativeProvider} from './portable-provider.mjs';
+import {assemblePortable} from './portable-assembly.mjs';
+import {publishNativeOutput} from './publish-output.mjs';
 import {outputFile, writeOutput} from './portable-layout.mjs';
 
 const is = new Is(false);
@@ -224,19 +226,19 @@ export function createMacOSNativeProvider({services, hostDirectory} = {}) {
             const target = macosTarget(request.targetRequest);
             const selected = hostDirectory ?? request.toolchain?.hostDirectory;
             const selectedHost = selected === undefined ? null : await requireHostDirectory(selected);
-            const artifact = await portable.build({
+            const artifact = await assemblePortable({
                 ...request, targetRequest: portableRequest(target),
                 async onEvent(event) {
-                    if (event.type !== 'native.payload.completed') await emit(onEvent, {...event, target: target.target});
+                    await emit(onEvent, {...event, target: target.target});
                 }
-            });
+            }, {services, packagedWeb: true, webKitDocumentLifecycle: true});
             const portableRoot = artifact.target.rootDir;
             let assembly;
             try {
                 const host = selectedHost ?? await releasedHostDirectory(path.resolve(request.outputRoot), artifact.manifest.sdk.version, target, {signal, onEvent});
                 throwIfAborted(signal);
                 assembly = await mkdtemp(path.join(path.resolve(request.outputRoot), 'arcane-macos-'));
-                const plist = outputFile(assembly, `${request.appDescriptor.id}.app/Contents/Info.plist`);
+                const plist = outputFile(assembly, 'Contents/Info.plist');
                 const contents = path.dirname(plist);
                 const root = path.join(contents, 'Resources');
                 const bundleRoot = path.dirname(contents);
@@ -256,9 +258,14 @@ export function createMacOSNativeProvider({services, hostDirectory} = {}) {
                 };
                 await writeFile(path.join(root, MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`, {signal});
                 throwIfAborted(signal);
-                await emit(onEvent, {type: 'native.payload.completed', target: target.target, appId: request.appDescriptor.id, outputRoot: root, bundleRoot});
-                throwIfAborted(signal);
-                return {...artifact, target: {...target, rootDir: root}, bundleRoot, manifest};
+                const publishedBundle = await publishNativeOutput({
+                    sourceRoot: bundleRoot, outputRoot: path.dirname(portableRoot), appId: request.appDescriptor.id, bundle: true, signal,
+                    async onPublished(finalBundle) {
+                        await emit(onEvent, {type: 'native.payload.completed', target: target.target, appId: request.appDescriptor.id,
+                            outputRoot: path.join(finalBundle, 'Contents', 'Resources'), bundleRoot: finalBundle});
+                    }
+                });
+                return {...artifact, target: {...target, rootDir: path.join(publishedBundle, 'Contents', 'Resources')}, bundleRoot: publishedBundle, manifest};
             } catch (error) {
                 return removeOwnedDirectories(assembly ? [portableRoot, assembly] : [portableRoot], error);
             }

package/src/native/portable-assembly.mjs

@@ -0,0 +1,180 @@
+import {mkdir, mkdtemp, readFile, realpath, rm} from 'node:fs/promises';
+import path from 'node:path';
+import Is from 'strong-type';
+import {createCoreClassicSource} from '../core-classic-source.mjs';
+import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
+import {SDK_ROOT, outputFile, writeOutput, copyRelease, copyCoreRuntime, coreEntrySource} from './portable-layout.mjs';
+
+const is = new Is(false);
+const MANIFEST = 'arcane-native.json';
+
+async function emit(onEvent, event) {
+    if (is.function(onEvent)) await onEvent(event);
+}
+
+function contains(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`));
+}
+
+async function futureRealPath(location) {
+    try { return await realpath(location); }
+    catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+        const parent = path.dirname(location);
+        if (parent === location) throw error;
+        return path.join(await futureRealPath(parent), path.basename(location));
+    }
+}
+
+async function outputDirectory(request) {
+    if (!is.string(request.outputRoot) || !request.outputRoot) {
+        throw new ArcaneError(ERROR_CODES.usage, 'Portable assembly requires an outputRoot.');
+    }
+    const output = await futureRealPath(path.resolve(request.outputRoot));
+    const protectedRoots = [SDK_ROOT, request.appReleaseRoot,
+        ...(request.dependencies?.map(function dependencyRoot(item) { return item.releaseRoot; }) ?? []),
+        ...(request.protectedRoots ?? [])];
+    for (const location of protectedRoots) {
+        if (!location) continue;
+        const root = await futureRealPath(path.resolve(location));
+        // SDK/release roots must never be replaced by generated output. A
+        // caller may select its ordinary project-local dist descendant.
+        if (contains(output, root) || (location !== SDK_ROOT && contains(root, output))) {
+            throw new ArcaneError(ERROR_CODES.usage, `Portable output overlaps selected source: ${location}.`);
+        }
+    }
+    await mkdir(output, {recursive: true});
+    return output;
+}
+
+function serviceSelection(services, release) {
+    return services.map(function selectService(service) {
+        if (!is.string(service?.module) || !release.files.includes(service.module)) {
+            throw new ArcaneError(ERROR_CODES.prerequisiteMissing, `The selected release does not contain service module ${String(service?.module)}.`);
+        }
+        return {...service, options: service.options === undefined ? {} : service.options};
+    });
+}
+
+function eventOwnerPath(release) {
+    const paths = release.files.filter(function sdkEventModule(relative) {
+        return relative === 'sdk/event-manager.mjs' || relative.endsWith('/sdk/event-manager.mjs')
+            || /^node_modules\/(?:@[^/]+\/)?[^/]+\/browser-runtime\/event-manager\.mjs$/u.test(relative);
+    });
+    if (paths.length !== 1) {
+        throw new ArcaneError(ERROR_CODES.prerequisiteMissing,
+            'The portable app release must select one shared SDK event-manager module.',
+            {details: {paths}});
+    }
+    // Native hosts mount the complete app directory at one local URL origin.
+    // An origin-root URL keeps nested navigable documents on the same owner.
+    return '/' + paths[0].split('/').map(encodeURIComponent).join('/');
+}
+
+/** Shared unfinished payload assembly; the final platform provider publishes it. */
+export async function assemblePortable(request = {}, {services, packagedWeb = false, webKitDocumentLifecycle = false} = {}) {
+    const {appDescriptor, release, signal, onEvent} = request;
+    throwIfAborted(signal);
+    const target = {...request.targetRequest};
+    const localAI = appDescriptor.native?.localAI;
+    const selectedServices = serviceSelection(services ?? appDescriptor.native?.services ?? [], release);
+    const eventOwnerModuleURL = eventOwnerPath(release);
+    const output = await outputDirectory(request);
+    throwIfAborted(signal);
+    // Unique assembly directories preserve earlier outputs and avoid
+    // overwriting an app's files or a concurrent packaging operation.
+    const root = await mkdtemp(path.join(output, 'arcane-portable-'));
+    const files = [];
+    try {
+        await emit(onEvent, {type: 'native.payload.started', appId: appDescriptor.id, outputRoot: root});
+        async function bundleSelectedRuntimes() {
+            if (localAI === undefined) return {runtimes: [], files: []};
+            const {bundleLocalAIRuntimes} = await import('../local-ai/install.mjs');
+            return bundleLocalAIRuntimes({
+                runtimes: localAI.runtimes,
+                directory: path.join(output, 'local-ai-runtimes'),
+                outputRoot: root,
+                platform: target.platform === 'windows' ? 'win32' : target.platform === 'macos' ? 'darwin' : target.platform,
+                architecture: target.architecture,
+                signal,
+                onEvent
+            });
+        }
+        // These outputs have separate directories. Join both owners
+        // before cleanup so neither can keep writing a removed assembly.
+        const preparation = await Promise.allSettled([
+            copyRelease({...request, releaseRoot: request.appReleaseRoot}, 'app', root, files, signal),
+            bundleSelectedRuntimes()
+        ]);
+        const failures = preparation.filter(function failedPreparation(result) { return result.status === 'rejected'; });
+        if (failures.length === 1) throw failures[0].reason;
+        if (failures.length > 1) {
+            throw new AggregateError(failures.map(function preparationError(result) { return result.reason; }),
+                'Portable application and local runtime preparation failed.');
+        }
+        const bundled = preparation[1].value;
+        files.push(...bundled.files);
+        const dependencies = [];
+        for (const [index, dependency] of (request.dependencies ?? []).entries()) {
+            const directory = `dependencies/${index}`;
+            await copyRelease(dependency, directory, root, files, signal);
+            dependencies.push({appId: dependency.appId, root: directory, release: dependency.release});
+        }
+        const sdk = await copyCoreRuntime(root, files, signal);
+        const selectedSdk = request.selectedSdk;
+        let appSdk;
+        if (selectedSdk && release.files.some(function selectedPackageFile(relative) {
+            return relative.startsWith(`${selectedSdk.packageSource}/`);
+        })) {
+            const destination = `app/${selectedSdk.packageSource}`;
+            let metadata;
+            if (release.files.includes(`${selectedSdk.packageSource}/package.json`)) {
+                metadata = JSON.parse(await readFile(outputFile(root, `${destination}/package.json`), 'utf8'));
+            } else {
+                metadata = await copyCoreRuntime(root, files, signal, {
+                    sourceRoot: selectedSdk.packageRoot, sdkDestination: destination
+                });
+            }
+            appSdk = {name: metadata.name, version: metadata.version, root: destination};
+        }
+        await writeOutput(root, 'package.json', '{"type":"module"}\n', files, signal);
+        await writeOutput(root, 'runtime/arcane-core.mjs', coreEntrySource(appDescriptor, sdk.version, selectedServices,
+            {localAI, runtimes: bundled.runtimes, packagedWeb}), files, signal);
+        await writeOutput(root, 'runtime/arcane-api.js', await createCoreClassicSource({
+            eventOwnerModuleURL, replayRuntimeState: true, webKitDocumentLifecycle
+        }), files, signal);
+        const manifest = {
+            schemaVersion: 1,
+            kind: 'arcane-portable-native',
+            sdk: {name: sdk.name, version: sdk.version},
+            ...(appSdk ? {appSdk} : {}),
+            app: appDescriptor,
+            target,
+            webRoot: 'app',
+            start: release.manifest?.app?.start ?? './index.html',
+            ...(appDescriptor.native?.window === undefined ? {} : {window: {...appDescriptor.native.window}}),
+            ...(appDescriptor.native?.launchContext === undefined ? {} : {launchContext: appDescriptor.native.launchContext}),
+            core: {
+                entry: 'runtime/arcane-core.mjs', transport: 'stdio', protocol: 'arcane/1', services: selectedServices,
+                ...(localAI === undefined ? {} : {localAIRuntimes: bundled.runtimes})
+            },
+            client: {
+                source: 'runtime/arcane-api.js', injection: 'document-created', eventOwnerModuleURL, replayRuntimeState: true,
+                ...(webKitDocumentLifecycle ? {webKitDocumentLifecycle: true} : {})
+            },
+            dependencies,
+            minimumCoreVersion: request.minimumCoreVersion ?? null,
+            files: [...files, MANIFEST]
+        };
+        await writeOutput(root, MANIFEST, JSON.stringify(manifest, null, 2) + '\n', files, signal);
+        throwIfAborted(signal);
+        return {app: appDescriptor, target: {...target, rootDir: root}, manifest};
+    } catch (error) {
+        try { await rm(root, {recursive: true, force: true}); }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], `Portable assembly failed; its incomplete output remains at ${root}.`);
+        }
+        throw error;
+    }
+}