arcane-os 0.95.0 → 0.96.0

package/src/local-ai/nemo-models.mjs

@@ -0,0 +1,160 @@
+import {randomUUID} from 'node:crypto';
+
+/** Selected native assets from NVIDIA NeMo-Speech.cpp v0.2.0 models/index.json. */
+export const NEMO_SPEECH_MODELS = {
+    stt: {
+        modelId: 'nemotron-3.5-asr-streaming-0.6b',
+        providerId: 'nemotron',
+        name: 'Nemotron 3.5 + speaker diarization',
+        members: [
+            {
+                path: 'nemotron-3.5-asr-streaming-0.6b.q8_0.gguf',
+                url: 'https://huggingface.co/nvidia/nemotron-3.5-asr-streaming-0.6b/resolve/1c8deaecc64b91f034d73e08dd8b64625eb3395d/nemotron-3.5-asr-streaming-0.6b.q8_0.gguf'
+            },
+            {
+                path: 'Nemotron-3-Diarization.q8_0.gguf',
+                url: 'https://huggingface.co/nvidia/Nemotron-3-Diarization/resolve/f667ed73aee57d40cc39428eb768b4fd87a0a29e/Nemotron-3-Diarization.q8_0.gguf'
+            }
+        ],
+        resourcePaths: {
+            model: 'nemotron-3.5-asr-streaming-0.6b.q8_0.gguf',
+            diarization: 'Nemotron-3-Diarization.q8_0.gguf'
+        }
+    },
+    tts: {
+        modelId: 'magpie',
+        providerId: 'magpie-native',
+        name: 'Magpie + NanoCodec',
+        members: [
+            {
+                path: 'magpie_tts_multilingual_357m.v2607.f16.gguf',
+                url: 'https://huggingface.co/nvidia/magpie_tts_multilingual_357m/resolve/19806879b16d3f2ccf28fb112b1bcd16a3c7923e/magpie_tts_multilingual_357m.v2607.f16.gguf'
+            },
+            {
+                path: 'nemo_nano_codec_22khz_1.89kbps_21.5fps.decoder.f16.gguf',
+                url: 'https://huggingface.co/nvidia/nemo-nano-codec-22khz-1.89kbps-21.5fps/resolve/fc00890b604aa2de298d2641ffc6c5f6caf8c4d7/nemo_nano_codec_22khz_1.89kbps_21.5fps.decoder.f16.gguf'
+            }
+        ],
+        archives: [
+            {
+                url: 'https://huggingface.co/nvidia/magpie_tts_multilingual_357m/resolve/19806879b16d3f2ccf28fb112b1bcd16a3c7923e/magpie_tts_multilingual_357m.nemo',
+                format: 'tar',
+                // These offsets select upstream TAR segments at the transport
+                // boundary. Their complete selected members stay unchanged.
+                ranges: [
+                    {start: 0, end: 20619263, stopBefore: 'model_weights.ckpt'},
+                    {start: 1459750400, end: 1470207999}
+                ],
+                members: [
+                    {
+                        path: 'tokenizer/05adc40366e149b69319acd4b28a4919_pt_br_prondict-v1.0.dict',
+                        member: '05adc40366e149b69319acd4b28a4919_pt_br_prondict-v1.0.dict'
+                    },
+                    {
+                        path: 'tokenizer/339da71c54b046f98cbcf38ef6d4ff67_hindi_phoneme_merged_phoneme_dict.dict',
+                        member: '339da71c54b046f98cbcf38ef6d4ff67_hindi_phoneme_merged_phoneme_dict.dict'
+                    },
+                    {
+                        path: 'tokenizer/41913ebaa70342058574da74293b7630_magpie_tts_multilingual_357m.nemo.speakers.json',
+                        member: '41913ebaa70342058574da74293b7630_magpie_tts_multilingual_357m.nemo.speakers.json'
+                    },
+                    {
+                        path: 'tokenizer/61d57a4ccb064d1e8e3d9f871c571932_heteronyms-052722',
+                        member: '61d57a4ccb064d1e8e3d9f871c571932_heteronyms-052722'
+                    },
+                    {
+                        path: 'tokenizer/74b3e832fe914a569fcd42b51d06b2f1_ipa_dict_nv23.05.txt',
+                        member: '74b3e832fe914a569fcd42b51d06b2f1_ipa_dict_nv23.05.txt'
+                    },
+                    {
+                        path: 'tokenizer/7dbc31751f224f2486090d59dc95b9f7_es_ES_nv230301.dict',
+                        member: '7dbc31751f224f2486090d59dc95b9f7_es_ES_nv230301.dict'
+                    },
+                    {
+                        path: 'tokenizer/c5e4ec2af5a14ce294f4b9edcc936535_de_nv230119.heteronym',
+                        member: 'c5e4ec2af5a14ce294f4b9edcc936535_de_nv230119.heteronym'
+                    },
+                    {
+                        path: 'tokenizer/cf01ab5c48c84f3282ef7888263361e5_de_nv230119.dict',
+                        member: 'cf01ab5c48c84f3282ef7888263361e5_de_nv230119.dict'
+                    },
+                    {
+                        path: 'tokenizer/dc7d60d6b15a4651b21c9ca2932b62c6_ipa_cmudict-0.7b_nv23.01.txt',
+                        member: 'dc7d60d6b15a4651b21c9ca2932b62c6_ipa_cmudict-0.7b_nv23.01.txt'
+                    },
+                    {path: 'tokenizer/model_config.yaml', member: 'model_config.yaml'}
+                ]
+            }
+        ],
+        resourcePaths: {
+            model: 'magpie_tts_multilingual_357m.v2607.f16.gguf',
+            codec: 'nemo_nano_codec_22khz_1.89kbps_21.5fps.decoder.f16.gguf',
+            tokenizerConfig: 'tokenizer/model_config.yaml'
+        }
+    }
+};
+
+/** Explicitly acquire the complete ASR and diarization selection. */
+export function prepareNemotronModels(options = {}) {
+    return prepareModels(NEMO_SPEECH_MODELS.stt, options);
+}
+
+/** Explicitly acquire Magpie, NanoCodec and the matching tokenizer members. */
+export function prepareMagpieModels(options = {}) {
+    return prepareModels(NEMO_SPEECH_MODELS.tts, options);
+}
+
+async function prepareModels(selection, {modelAssets, workingDirectory, directories, id = randomUUID(), signal, onProgress, refresh = false}) {
+    if (typeof modelAssets?.prepare !== 'function' || typeof modelAssets?.release !== 'function') {
+        throw new TypeError('Native speech preparation requires the existing model-assets service.');
+    }
+    signal?.throwIfAborted();
+    let projection;
+    if (directories !== undefined && !refresh) {
+        if (typeof modelAssets.discover !== 'function' || typeof modelAssets.openExisting !== 'function') {
+            throw new TypeError('Installed native speech discovery requires the model-assets discover and openExisting methods.');
+        }
+        const discovered = await modelAssets.discover({
+            directories, signal,
+            catalog: [{id: selection.modelId, members: selection.members, archives: selection.archives,
+                entryPath: selection.resourcePaths.model}]
+        });
+        signal?.throwIfAborted();
+        const existing = discovered.models.find(function completeSelection(model) {
+            return model.complete && model.catalogId === selection.modelId;
+        });
+        if (existing) {
+            await onProgress?.({phase: 'reuse', completed: 0, total: existing.members.length, unit: 'files'});
+            signal?.throwIfAborted();
+            projection = await modelAssets.openExisting({id, directory: existing.directory, members: existing.members, signal});
+        }
+    }
+    const reused = projection !== undefined;
+    projection ??= await modelAssets.prepare({
+        id, workingDirectory, members: selection.members,
+        archives: selection.archives, signal, onProgress, refresh
+    });
+    let released;
+    function release() {
+        released ??= Promise.resolve().then(function releasePreparation() { return modelAssets.release(projection.id); });
+        return released;
+    }
+    try {
+        signal?.throwIfAborted();
+        if (reused) {
+            await onProgress?.({phase: 'ready', completed: projection.members.length, total: projection.members.length, unit: 'files'});
+            signal?.throwIfAborted();
+        }
+        return {
+            assetProjectionId: projection.id, directory: projection.directory,
+            members: projection.members, resourcePaths: {...selection.resourcePaths}, release
+        };
+    } catch (error) {
+        try {
+            await release();
+        } catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], 'Native speech preparation and cleanup failed.', {cause: error});
+        }
+        throw error;
+    }
+}

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

@@ -3,10 +3,12 @@ import {randomUUID} from 'node:crypto';
 import {createArcaneEventSource} from '../../event-manager.mjs';
 import {createNemotronHelper, deferred, encodeNemotronAudio, nemotronError} from './helper.mjs';
 
+export {NEMO_SPEECH_MODELS, prepareNemotronModels, prepareMagpieModels} from '../nemo-models.mjs';
+
 /** Retain one selected recognizer and diarizer across explicit utterance endpoints. */
 export function createNemotronRuntime(
     {runtime, prepare, modelId = 'nemotron-3.5-asr-streaming-0.6b', modelPath,
-        diarizationModelPath, gpu, onEvent} = {}
+        diarizationModelPath, modelAssets, assetProjectionId, resourcePaths, gpu, onEvent} = {}
 ) {
     if (!runtime && typeof prepare !== 'function') {
         throw new TypeError('Nemotron requires a prepared runtime or a prepare function.');
@@ -20,6 +22,10 @@ export function createNemotronRuntime(
     let selected = modelId;
     let selectedModelPath = modelPath ?? runtime?.modelPath;
     let selectedDiarizationPath = diarizationModelPath ?? runtime?.diarizationModelPath;
+    let selectedProjectionId = assetProjectionId;
+    let selectedResourcePaths = resourcePaths;
+    let retainedAssets = null;
+    let activePaths = null;
     let selectedGpu = gpu ?? runtime?.gpu;
     let streamSequence = 0;
     let state = 'unloaded';
@@ -37,8 +43,10 @@ export function createNemotronRuntime(
         return {
             providerId: 'nemotron', modelId: selected, state,
             loaded: state === 'ready', busy: active !== null,
-            modelPath: selectedModelPath ?? null,
-            diarizationModelPath: selectedDiarizationPath ?? null,
+            modelPath: activePaths?.model ?? selectedModelPath ?? null,
+            diarizationModelPath: activePaths ? activePaths.diarization ?? null : selectedDiarizationPath ?? null,
+            assetProjectionId: selectedProjectionId ?? null,
+            resourcePaths: selectedResourcePaths ? {...selectedResourcePaths} : null,
             requestedGpu: selectedGpu ?? null,
             observedBackend: null,
             nativeVersion: helper?.current().metadata?.version ?? null,
@@ -95,6 +103,11 @@ export function createNemotronRuntime(
         const changed = (options.modelId !== undefined && options.modelId !== selected)
             || (options.modelPath !== undefined && options.modelPath !== selectedModelPath)
             || (options.diarizationModelPath !== undefined && options.diarizationModelPath !== selectedDiarizationPath)
+            || (Object.hasOwn(options, 'assetProjectionId') && options.assetProjectionId !== selectedProjectionId)
+            || (Object.hasOwn(options, 'resourcePaths') && (
+                options.resourcePaths?.model !== selectedResourcePaths?.model
+                || options.resourcePaths?.diarization !== selectedResourcePaths?.diarization
+            ))
             || (options.gpu !== undefined && options.gpu !== selectedGpu);
         if ((loading || helper || active) && changed) {
             return Promise.reject(nemotronError('NEMOTRON_MODEL_LOADED', 'Unload the current Nemotron selection before replacing it.'));
@@ -107,12 +120,22 @@ export function createNemotronRuntime(
         selected = options.modelId ?? selected;
         selectedModelPath = options.modelPath ?? selectedModelPath;
         selectedDiarizationPath = options.diarizationModelPath ?? selectedDiarizationPath;
+        if (Object.hasOwn(options, 'assetProjectionId')) selectedProjectionId = options.assetProjectionId;
+        if (Object.hasOwn(options, 'resourcePaths')) selectedResourcePaths = options.resourcePaths;
         selectedGpu = options.gpu ?? selectedGpu;
+        if (selectedProjectionId && typeof modelAssets?.retain !== 'function') {
+            return Promise.reject(nemotronError('NEMOTRON_RESOURCES_UNAVAILABLE', 'A model projection requires the existing model-assets owner.'));
+        }
+        // Retain synchronously before callers can release preparation ownership.
+        const previousAssets = retainedAssets;
+        const assets = selectedProjectionId ? {use: modelAssets.retain(selectedProjectionId), release: null} : null;
+        retainedAssets = assets;
         state = 'loading';
         error = null;
         loadController = new AbortController();
         const ownerSignal = loadController.signal;
         async function loadModel() {
+            await releaseModelAssets(previousAssets);
             ownerSignal.throwIfAborted();
             if (!runtime) {
                 runtime = await prepare(
@@ -123,10 +146,15 @@ export function createNemotronRuntime(
             selectedModelPath ??= runtime.modelPath;
             selectedDiarizationPath ??= runtime.diarizationModelPath;
             selectedGpu ??= runtime.gpu;
-            if (typeof runtime.helperExecutable !== 'string' || typeof selectedModelPath !== 'string') {
+            const paths = assets ? {
+                model: projectedModelPath(assets, 'model'),
+                diarization: selectedResourcePaths?.diarization === undefined
+                    ? undefined : projectedModelPath(assets, 'diarization')
+            } : {model: selectedModelPath, diarization: selectedDiarizationPath};
+            if (typeof runtime.helperExecutable !== 'string' || typeof paths.model !== 'string') {
                 throw nemotronError('NEMOTRON_MODEL_UNAVAILABLE', 'Select the prepared Nemotron helperExecutable and ASR modelPath.');
             }
-            if (selectedDiarizationPath !== undefined && typeof selectedDiarizationPath !== 'string') {
+            if (paths.diarization !== undefined && typeof paths.diarization !== 'string') {
                 throw new TypeError('diarizationModelPath must be the selected local model path.');
             }
             if (!Number.isInteger(selectedGpu) || selectedGpu < -1) {
@@ -134,10 +162,11 @@ export function createNemotronRuntime(
             }
             const session = createNemotronHelper(
                 {
-                    runtime, modelPath: selectedModelPath, diarizationModelPath: selectedDiarizationPath,
+                    runtime, modelPath: paths.model, diarizationModelPath: paths.diarization,
                     gpu: selectedGpu, onEvent
                 }
             );
+            activePaths = paths;
             helper = session;
             function cancelLoad() {
                 session.stop(ownerSignal.reason).catch(observeRetainedFailure);
@@ -179,7 +208,14 @@ export function createNemotronRuntime(
                 ownerSignal.removeEventListener('abort', cancelLoad);
             }
         }
-        function loadFailed(failure) {
+        async function loadFailed(failure) {
+            try {
+                await releaseModelAssets(assets);
+            } catch (cleanupFailure) {
+                failure = new AggregateError([failure, cleanupFailure], 'Nemotron model loading and asset cleanup failed.', {cause: failure});
+            }
+            if (retainedAssets === assets) retainedAssets = null;
+            activePaths = null;
             const cancelledLoad = ownerSignal.aborted && (
                 failure === ownerSignal.reason || failure?.code === 'ARCANE_CANCELLED' || failure?.name === 'AbortError'
             );
@@ -200,6 +236,21 @@ export function createNemotronRuntime(
         return waitFor(loading, signal);
     }
 
+    function projectedModelPath(assets, role) {
+        const memberPath = selectedResourcePaths?.[role];
+        const member = assets.use.members.find(function selectedMember(value) { return value.path === memberPath; });
+        if (!member) {
+            throw nemotronError('NEMOTRON_RESOURCE_UNAVAILABLE', `The retained Nemotron projection has no member ${String(memberPath)} for ${role}.`);
+        }
+        return member.nativePath;
+    }
+
+    function releaseModelAssets(assets) {
+        if (!assets) return Promise.resolve();
+        assets.release ??= Promise.resolve().then(function releaseNativeModelUse() { return assets.use.release(); });
+        return assets.release;
+    }
+
     function openStream({sampleRate = 16000, languageCode, model, onUpdate, signal} = {}) {
         signal?.throwIfAborted();
         if (model !== undefined && model !== selected) {
@@ -547,6 +598,11 @@ export function createNemotronRuntime(
             const session = helper;
             try { if (session) await session.stop(); } catch (failure) { failures.push(failure); }
             if (helper === session) helper = null;
+            // stop joins actual native exit even when it reports diagnostics.
+            const assets = retainedAssets;
+            try { await releaseModelAssets(assets); } catch (failure) { failures.push(failure); }
+            if (retainedAssets === assets) retainedAssets = null;
+            activePaths = null;
             if (failures.length) throw new AggregateError(failures, 'Nemotron cleanup failed.');
             error = null;
             state = 'unloaded';

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