arcane-os 0.66.0 → 0.68.0

package/runtime/arcane/modules/PreferenceStore.js

@@ -153,21 +153,26 @@ function nativeAdapter(){
     return preferences;
 }
 
-function isUnsupportedNativeAdapter(error){
-    return error?.code==='ANDROID_CAPABILITY_UNSUPPORTED';
+function isUnsupportedNativeAdapter(error,method){
+    return error?.code==='ANDROID_CAPABILITY_UNSUPPORTED'
+        ||(error?.code==='METHOD_NOT_ALLOWED'
+            &&error.reason==='core-namespace-unavailable'
+            &&error.namespace==='preferences'
+            &&error.method===`preferences.${method}`);
 }
 
-function preferenceAdapter(){
+function preferenceAdapter(assertActive){
     const local=localAdapter('arcane.preferences');
     if(is.function(globalThis.arcaneAndroid?.postMessage)) return local;
     const native=nativeAdapter();
     if(!native) return local;
     let active=native;
-    async function call(method,args){
+    async function call(method,args,context){
         try{
             return await active[method](...args);
         }catch(error){
-            if(active!==native||!isUnsupportedNativeAdapter(error)) throw error;
+            if(active!==native||!isUnsupportedNativeAdapter(error,method)) throw error;
+            assertActive(context?.signal);
             active=local;
             delete adapter.setMany;
             if(!is.function(active[method])) throw error;
@@ -175,19 +180,19 @@ function preferenceAdapter(){
         }
     }
     const adapter={
-        async get(key){
-            return call('get',[key]);
+        async get(key,context){
+            return call('get',[key,context],context);
         },
-        async set(key,value){
-            return call('set',[key,value]);
+        async set(key,value,context){
+            return call('set',[key,value,context],context);
         },
-        async delete(key){
-            return call('delete',[key]);
+        async delete(key,context){
+            return call('delete',[key,context],context);
         }
     };
     if(is.function(native.setMany)){
         adapter.setMany=async function setMany(entries,context){
-            return call('setMany',[entries,context]);
+            return call('setMany',[entries,context],context);
         };
     }
     return adapter;
@@ -204,7 +209,7 @@ export default class PreferenceStore extends EventTarget{
         super();
         this.namespace=String(namespace||'arcane');
         this.schema=preferenceSchema(schema);
-        this.adapter=validateAdapter(adapter||preferenceAdapter());
+        this.adapter=validateAdapter(adapter||preferenceAdapter(this.#assertOperationActive.bind(this)));
         this.values=this.defaults();
         this.#events=createArcaneEventSource(
             this,

package/runtime/arcane/modules/SystemAppearance.js

@@ -8,16 +8,34 @@ export default class SystemAppearance{
 
     async current(){
         if(!this.api||!is.function(this.api.current)) return {supported:false,platform:'browser'};
-        return this.api.current();
+        try{
+            return await this.api.current();
+        }catch(error){
+            return unsupportedNamespace(error,'current');
+        }
     }
 
     async apply(input={}){
         if(!this.available()) return {supported:false,platform:'browser'};
         const scheme=['system','light','dark'].includes(input.scheme)?input.scheme:'system';
-        return this.api.apply({
-            scheme,
-            captionColor:scheme==='system'?null:input.captionColor||null,
-            textColor:scheme==='system'?null:input.textColor||null
-        });
+        try{
+            return await this.api.apply({
+                scheme,
+                captionColor:scheme==='system'?null:input.captionColor||null,
+                textColor:scheme==='system'?null:input.textColor||null
+            });
+        }catch(error){
+            return unsupportedNamespace(error,'apply');
+        }
     }
 }
+
+function unsupportedNamespace(error,method){
+    if(error?.code==='METHOD_NOT_ALLOWED'
+        &&error.reason==='core-namespace-unavailable'
+        &&error.namespace==='appearance'
+        &&error.method===`appearance.${method}`){
+        return {supported:false,reason:'core-namespace-unavailable',error};
+    }
+    throw error;
+}

package/src/core/repositories.mjs

@@ -4,7 +4,8 @@ import path from 'node:path';
 import Is from 'strong-type';
 import {ArcaneError, throwIfAborted} from '../errors.mjs';
 import {runProcess} from '../process.mjs';
-import {repositoryPull, repositoryPush, repositoryStatus} from '../repository.mjs';
+import {captureRepositoryTarget, repositoryConfiguration, repositoryPull, repositoryPush,
+    repositoryPushArguments, repositoryStatus} from '../repository.mjs';
 import {createGitIdentityRunner} from '../git-identity.mjs';
 
 export {readGitIdentity} from '../git-identity.mjs';
@@ -152,29 +153,46 @@ export function createRepositoryWorkspace(
         );
     }
 
-    function pull({signal} = {}) {
+    function configuration({signal} = {}) {
+        return accept(
+            function readRepositoryConfiguration() {
+                return repositoryConfiguration({workspaceRoot: repositoryDirectory, signal, onEvent, run: execute});
+            },
+            signal
+        );
+    }
+
+    function pull({target, signal} = {}) {
+        let selectedTarget;
+        try { selectedTarget = captureRepositoryTarget(target); }
+        catch (error) { return Promise.reject(error); }
         return accept(
             async function pullRepository() {
                 await prepare(signal);
-                return repositoryPull({workspaceRoot: repositoryDirectory, signal, onEvent, run: execute});
+                return repositoryPull({workspaceRoot: repositoryDirectory, target: selectedTarget, signal, onEvent, run: execute});
             },
             signal
         );
     }
 
-    function push({signal} = {}) {
+    function push({target, signal} = {}) {
+        let selectedTarget;
+        try { selectedTarget = captureRepositoryTarget(target); }
+        catch (error) { return Promise.reject(error); }
         return accept(
             async function pushRepository() {
                 await prepare(signal);
-                return repositoryPush({workspaceRoot: repositoryDirectory, signal, onEvent, run: execute});
+                return repositoryPush({workspaceRoot: repositoryDirectory, target: selectedTarget, signal, onEvent, run: execute});
             },
             signal
         );
     }
 
-    function write({files, message, signal} = {}) {
+    function write({files, message, target, signal} = {}) {
         let selectedFiles;
+        let selectedTarget;
         try {
+            selectedTarget = captureRepositoryTarget(target);
             requireString(message, 'message');
             if (!message.isWellFormed()) throw new TypeError('message cannot be represented completely as UTF-8 text.');
             if (!is.array(files) || files.length === 0) {
@@ -210,6 +228,7 @@ export function createRepositoryWorkspace(
             async function writeRepositoryFiles() {
                 const outcome = {
                     directory: repositoryDirectory,
+                    ...(selectedTarget === undefined ? {} : {target: {...selectedTarget}}),
                     state: 'local',
                     stage: 'prepare',
                     paths: selectedFiles.map(function selectedPath(file) { return file.path; }),
@@ -321,7 +340,7 @@ export function createRepositoryWorkspace(
                         ['--literal-pathspecs', 'commit', '--only', '--cleanup=verbatim', '--file', '-', '--', ...outcome.paths],
                         commitMessage()
                     );
-                    await executeGit('push', ['push']);
+                    await executeGit('push', repositoryPushArguments(selectedTarget));
                     outcome.stage = 'complete';
                     return outcome;
                 } catch (cause) {
@@ -357,7 +376,7 @@ export function createRepositoryWorkspace(
         return closing;
     }
 
-    return {directory: repositoryDirectory, open, status, pull, push, write, close, drain: close, dispose: close};
+    return {directory: repositoryDirectory, open, status, configuration, pull, push, write, close, drain: close, dispose: close};
 }
 
 function requireString(value, name) {

package/src/core/runtime.mjs

@@ -150,11 +150,22 @@ class CoreRuntime {
         };
     }
 
+    async getService(name) {
+        if (this.#closing) throw failure('CORE_CLOSING', 'Core is closing.');
+        const service = this.#services.get(name);
+        if (!service) throw failure('CORE_SERVICE_UNAVAILABLE', `Core service ${String(name)} is not registered.`);
+        await this.#startService(service);
+        return service.definition;
+    }
+
     #serviceContext(service) {
         const runtime = this;
         return {
             application: this.#application,
             service: service.name,
+            getService(name) {
+                return runtime.getService(name);
+            },
             emit(event, data) {
                 return runtime.emit(event, data);
             }
@@ -256,7 +267,21 @@ class CoreRuntime {
 
     #request(frame) {
         const registration = this.#methods.get(frame.method);
-        if (!registration) throw failure('METHOD_NOT_ALLOWED', `Core does not expose ${frame.method}.`);
+        if (!registration) {
+            const namespace = frame.method.split('.')[0];
+            const prefix = `${namespace}.`;
+            const namespacePresent = this.#services.has(namespace)
+                || [...this.#methods.keys(), 'system.ping', 'app.current', 'version.current'].some(
+                    function inNamespace(method) { return method.startsWith(prefix); }
+                );
+            throw new CoreError({
+                code: 'METHOD_NOT_ALLOWED',
+                message: `Core does not expose ${frame.method}.`,
+                reason: namespacePresent ? 'core-method-unavailable' : 'core-namespace-unavailable',
+                namespace,
+                method: frame.method
+            });
+        }
         const {service, handle, lifetime} = registration;
         const controller = new AbortController();
         const request = {id: frame.id, method: frame.method, lifetime, controller, task: null};

package/src/core/services/decisions.mjs

@@ -0,0 +1,144 @@
+import path from 'node:path';
+import {createNativeDecisionModel} from '../../local-ai/decisions.mjs';
+import {createArcaneEventSource} from '../../event-manager.mjs';
+import {CoreError} from '../../../browser-runtime/core/contracts.mjs';
+import {encodeTensorMap} from '../../../browser-runtime/ai/onnx-tensors.mjs';
+
+/** App-owned selection; shared typed-decision execution, without a renderer. */
+export function createNativeDecisionService(configuration = {}, {appRoot = process.cwd()} = {}) {
+    const events = createArcaneEventSource({}, {source: 'core-decisions', eventTypes: ['decisions.state']});
+    const lifetime = new AbortController();
+    let context;
+    let model;
+    let loading;
+    let loadController;
+    let releasing;
+    let closing;
+    let unsubscribe;
+
+    function current() {
+        return model?.current() ?? {
+            family: 'laya', model: configuration.model ?? 'onnx-community/laya-typed-decisions-ONNX',
+            revision: configuration.revision ?? 'main', dtype: configuration.dtype ?? 'fp32',
+            state: closing ? 'disposed' : 'unloaded', loaded: false, busy: Boolean(loading),
+            activeRequests: 0, progress: null, error: null, execution: null
+        };
+    }
+
+    function publish(value = current()) {
+        events.dispatch('decisions.state', value);
+        context?.emit('decisions.state', value);
+    }
+
+    function subscribe(listener, {emitCurrent = true, signal} = {}) {
+        const stop = events.on('decisions.state', function changed(event) { listener(event.detail); }, {signal});
+        try { if (emitCurrent && !signal?.aborted) listener(current()); }
+        catch (error) { stop(); throw error; }
+        return stop;
+    }
+
+    function operationSignal(signal) { return signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal; }
+
+    function load({signal} = {}) {
+        operationSignal(signal).throwIfAborted();
+        if (!context) throw new CoreError({code: 'CORE_NOT_READY', message: 'Register and start the decision service with Core before loading.'});
+        if (loading) return observeLoad(loading, loadController, signal);
+        if (model?.current().loaded) return Promise.resolve(model.current());
+        loadController = new AbortController();
+        const controller = loadController;
+        const selectedSignal = AbortSignal.any([lifetime.signal, controller.signal]);
+        const precedingRelease = releasing;
+        loading = Promise.resolve().then(async function loadSelectedModel() {
+            selectedSignal.throwIfAborted();
+            if (precedingRelease) await precedingRelease;
+            selectedSignal.throwIfAborted();
+            if (model) await model.dispose();
+            unsubscribe?.();
+            // Only the explicit load waits for its native dependencies. Merely
+            // registering this service does not download a model or delay UI.
+            const [localAI, modelAssets] = await Promise.all([
+                context.getService('local-ai'),
+                configuration.paths ? undefined : context.getService('model-assets')
+            ]);
+            selectedSignal.throwIfAborted();
+            const paths = configuration.paths && Object.fromEntries(
+                Object.entries(configuration.paths).map(function nativePath([name, value]) { return [name, path.resolve(appRoot, value)]; })
+            );
+            model = createNativeDecisionModel({
+                ...configuration, paths, onnx: localAI.getONNXRuntime(), modelAssets,
+                signal: lifetime.signal
+            });
+            unsubscribe = model.subscribe(publish);
+            return model.load({signal: selectedSignal});
+        });
+        function settled() { loading = undefined; loadController = undefined; publish(); }
+        loading.then(settled, settled);
+        publish();
+        return observeLoad(loading, controller, signal);
+    }
+
+    function observeLoad(task, controller, signal) {
+        function abort() { controller.abort(signal.reason); }
+        signal?.addEventListener('abort', abort, {once: true});
+        if (signal?.aborted) abort();
+        return task.finally(function detachLoadCaller() { signal?.removeEventListener('abort', abort); });
+    }
+
+    async function evaluate(rows, {signal, runOptions} = {}) {
+        const selectedSignal = operationSignal(signal);
+        selectedSignal.throwIfAborted();
+        if (!model) throw new CoreError({code: 'ARCANE_DECISION_NOT_LOADED', message: 'Load the selected native decision model before evaluating.'});
+        return model.evaluate(rows, {signal: selectedSignal, runOptions});
+    }
+
+    function unload() {
+        if (releasing) return releasing;
+        // An unload during model preparation must cancel that accepted load,
+        // rather than wait for it to download and activate first.
+        loadController?.abort(new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message: 'The native decision load was cancelled.'}));
+        const task = model?.unload() ?? Promise.resolve();
+        const acceptedLoad = loading;
+        releasing = Promise.resolve().then(async function releaseSelectedModel() {
+            const results = await Promise.allSettled([task, acceptedLoad]);
+            if (results[0].status === 'rejected') throw results[0].reason;
+            return current();
+        });
+        function released() { releasing = undefined; }
+        releasing.then(released, released);
+        return releasing;
+    }
+
+    function dispose() {
+        if (closing) return closing;
+        const reason = new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message: 'The native decision service is closing.'});
+        closing = Promise.resolve().then(async function closeDecisionService() {
+            const failures = [];
+            try { await loading; } catch (error) { if (!lifetime.signal.aborted) failures.push(error); }
+            try { await model?.dispose(); } catch (error) { failures.push(error); }
+            unsubscribe?.();
+            publish();
+            events.dispose();
+            if (failures.length) throw new AggregateError(failures, 'Closing the decision service failed.');
+        });
+        lifetime.abort(reason);
+        return closing;
+    }
+
+    return {
+        name: configuration.name ?? 'decisions', current, subscribe, load, evaluate, classify: evaluate, unload, dispose,
+        start(serviceContext) { context = serviceContext; },
+        methods: {
+            'decisions.status': current,
+            'decisions.load': function loadRequest(parameters, request) { return load({signal: request.signal}); },
+            'decisions.evaluate': async function evaluateRequest({rows, runOptions}, request) {
+                const result = await evaluate(rows, {runOptions, signal: request.signal});
+                // Typed arrays retain their complete values through Core's
+                // existing JSON tensor encoding, only at this transport edge.
+                return {...result, outputs: encodeTensorMap(result.outputs)};
+            },
+            'decisions.unload': {lifetime: 'service', handle: unload}
+        }
+    };
+}
+
+export default createNativeDecisionService;

package/src/core/services/local-ai.mjs

@@ -149,8 +149,13 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
         };
     }
 
+    function runtimeRecord(engine) {
+        return {...engine.state, models: [...engine.models],
+            ...(engine.id === 'llama.cpp' ? {released: engine.released === true} : {})};
+    }
+
     function snapshot() {
-        const records = [...engines.values()].map(function runtimeRecord(engine) { return {...engine.state, models: [...engine.models]}; });
+        const records = [...engines.values()].map(runtimeRecord);
         if (onnxSelected) records.push(onnxStatus());
         const ollama = records.find(function ollamaRecord(record) { return record.id === 'ollama'; });
         return {
@@ -283,7 +288,7 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
             engine.models = [...merged.values()];
         }
         publish();
-        return {...engine.state, models: [...engine.models]};
+        return runtimeRecord(engine);
     }
 
     function observeModels(engine) {
@@ -347,7 +352,7 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
         return recovering;
     }
 
-    async function engineReady(id, signal, {retryLoading = false} = {}) {
+    async function engineReady(id, signal, {retryLoading = false, resumeReleased = true} = {}) {
         signal?.throwIfAborted();
         const engine = engines.get(id);
         if (!engine) throw failure('LOCAL_AI_RUNTIME_NOT_SELECTED', `${id} is not selected in this application's localAI configuration.`);
@@ -358,13 +363,28 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
         if (retryLoading && engine.state.state === 'loading') {
             await awaitReadiness(restartEngine(engine), signal);
         }
-        if (engine.released) { engine.released = false; startEngine(engine); }
+        if (engine.released) {
+            if (!resumeReleased) return engine;
+            engine.released = false;
+            startEngine(engine);
+        }
         await awaitReadiness(engine.ready, signal);
         signal?.throwIfAborted();
         if (!engine.state.available) throw failure('LOCAL_AI_RUNTIME_UNAVAILABLE', `${id} is unavailable.`);
         return engine;
     }
 
+    function observeLlama(signal) {
+        signal?.throwIfAborted();
+        const engine = engines.get('llama.cpp');
+        if (!engine) throw failure('LOCAL_AI_RUNTIME_NOT_SELECTED', "llama.cpp is not selected in this application's localAI configuration.");
+        // Observation neither waits for startup nor starts a released engine.
+        if (!engine.state.available || engine.released || engine.stopping || engine.recovering || engine.signal.aborted) {
+            return runtimeRecord(engine);
+        }
+        return refreshModels(engine, signal);
+    }
+
     function waitForModel(engine, model, signal) {
         return new Promise(function awaitModel(resolve, reject) {
             let unsubscribe;
@@ -563,6 +583,9 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
     const service = {
         name: 'local-ai',
         current: snapshot,
+        getONNXRuntime() {
+            return requireONNX();
+        },
         async start(currentContext) {
             context = currentContext;
             if (prepare) {
@@ -633,17 +656,16 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
                 return snapshot();
             },
             'llama.status': async function llamaStatus(_parameters, request) {
-                const engine = await engineReady('llama.cpp', request.signal);
-                return refreshModels(engine, request.signal);
+                return observeLlama(request.signal);
             },
             'llama.models': async function llamaModels(_parameters, request) {
-                const engine = await engineReady('llama.cpp', request.signal);
-                const status = await refreshModels(engine, request.signal);
+                const status = await observeLlama(request.signal);
                 return {models: status.models};
             },
             'llama.load': loadLlama,
             'llama.unload': async function unloadLlama({model}, request) {
-                const engine = await engineReady('llama.cpp', request.signal);
+                const engine = await engineReady('llama.cpp', request.signal, {resumeReleased: false});
+                if (engine.released) return {...engine.state, models: [...engine.models], released: true, unloaded: true};
                 engine.loadControllers.get(model)?.abort(failure('LOCAL_AI_MODEL_UNLOADED', `The application unloaded ${model}.`));
                 if (engine.loads.has(model)) await Promise.allSettled([engine.loads.get(model)]);
                 if (!engine.router) {

package/src/core/services/model-assets.mjs

@@ -10,7 +10,7 @@ function failure(code, message) {
     return new CoreError({code, message});
 }
 
-/** Working files for native engines. The browser's stored assets stay authoritative. */
+/** Working files for native engines. Caller-selected source assets stay authoritative. */
 export function createModelAssetService({appRoot = process.cwd()} = {}) {
     const projections = new Map();
     let context;
@@ -63,6 +63,7 @@ export function createModelAssetService({appRoot = process.cwd()} = {}) {
             const errors = [];
             let filesClosed = false;
             try { await record.opening; } catch (error) { record.error ??= error; }
+            try { await record.downloading; } catch (error) { record.error ??= error; }
             try { await record.finishing; } catch (error) { record.error ??= error; }
             try { await closeMembers(record); filesClosed = true; } catch (error) { errors.push(error); }
             if (record.directory && filesClosed) {
@@ -87,10 +88,16 @@ export function createModelAssetService({appRoot = process.cwd()} = {}) {
 
     function releasePreparation(record) {
         record.preparationOwned = false;
+        record.downloadController?.abort(failure('MODEL_ASSET_PROJECTION_RELEASED', 'Model asset preparation was released.'));
         publish(record);
         return cleanup(record);
     }
 
+    function release(id) {
+        const record = projections.get(id);
+        return record ? releasePreparation(record) : Promise.resolve({id, state: 'released'});
+    }
+
     async function failedOperation(record, error) {
         record.error = error;
         record.state = 'error';
@@ -165,19 +172,98 @@ export function createModelAssetService({appRoot = process.cwd()} = {}) {
         const member = record.members[memberIndex];
         if (!member) throw new TypeError('Select an existing model asset member.');
         try {
-            const task = member.tail.then(async function appendOriginalContent() {
-                request.signal.throwIfAborted();
-                if (!record.preparationOwned) throw failure('MODEL_ASSET_PROJECTION_RELEASED', 'Model asset preparation was released.');
-                await member.handle.appendFile(Buffer.from(contentBase64, 'base64'));
-                request.signal.throwIfAborted();
-            });
-            // File writes remain ordered; unrelated member files write independently.
-            member.tail = task.catch(function observeWriteFailure() {});
-            await task;
+            await appendMemberContent(record, member, Buffer.from(contentBase64, 'base64'), request.signal);
             return {id, memberIndex, written: true};
         } catch (error) { return failedOperation(record, error); }
     }
 
+    function appendMemberContent(record, member, content, signal) {
+        const task = member.tail.then(async function appendOriginalContent() {
+            signal.throwIfAborted();
+            if (!record.preparationOwned) throw failure('MODEL_ASSET_PROJECTION_RELEASED', 'Model asset preparation was released.');
+            await member.handle.appendFile(content);
+            signal.throwIfAborted();
+        });
+        // File writes remain ordered; unrelated member files write independently.
+        member.tail = task.catch(function observeWriteFailure() {});
+        return task;
+    }
+
+    async function prepare({id, workingDirectory, members, signal, onProgress} = {}) {
+        const controller = new AbortController();
+        const operationSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+        const request = {signal: operationSignal};
+        let record;
+        let completed = 0;
+        let firstFailure;
+
+        async function progress(phase, memberIndex) {
+            operationSignal.throwIfAborted();
+            await onProgress?.({
+                phase, completed, total: members.length, unit: 'files',
+                ...(memberIndex === undefined ? {} : {memberIndex, path: members[memberIndex].path})
+            });
+            operationSignal.throwIfAborted();
+        }
+
+        async function downloadMember(member, memberIndex) {
+            try {
+                await progress('download', memberIndex);
+                const response = await fetch(member.url, {signal: operationSignal});
+                if (!response.ok) {
+                    const error = failure('MODEL_ASSET_DOWNLOAD_FAILED', `Model asset request failed: ${response.status} ${response.statusText}`);
+                    error.url = member.url;
+                    error.status = response.status;
+                    error.response = await response.text();
+                    throw error;
+                }
+                if (!response.body) throw failure('MODEL_ASSET_DOWNLOAD_FAILED', `Model asset response has no content stream: ${member.url}`);
+                for await (const content of response.body) {
+                    operationSignal.throwIfAborted();
+                    await appendMemberContent(record, record.members[memberIndex], content, operationSignal);
+                    await progress('download', memberIndex);
+                }
+                completed += 1;
+                await progress('download', memberIndex);
+            } catch (error) {
+                firstFailure ??= error;
+                controller.abort(error);
+                throw error;
+            }
+        }
+
+        try {
+            await openProjection({id, workingDirectory, members}, request);
+            record = requireProjection(id);
+            operationSignal.throwIfAborted();
+            if (!record.preparationOwned || closing) {
+                throw failure('MODEL_ASSET_PROJECTION_RELEASED', 'Model asset preparation was released.');
+            }
+            record.downloadController = controller;
+            // Cleanup joins this transfer-only task. Its rejection handler below
+            // may release preparation without waiting on itself.
+            record.downloading = Promise.resolve().then(async function downloadMembers() {
+                await progress('open');
+                const results = await Promise.allSettled(members.map(downloadMember));
+                const errors = results.filter(function rejected(result) { return result.status === 'rejected'; })
+                    .map(function reason(result) { return result.reason; });
+                if (errors.length > 1) {
+                    throw new AggregateError(errors, 'Downloading model asset members failed.', {cause: firstFailure});
+                }
+                if (errors.length) throw errors[0];
+            });
+            await record.downloading;
+            await progress('complete');
+            const projection = await completeProjection({id}, request);
+            await progress('ready');
+            return projection;
+        } catch (error) {
+            controller.abort(error);
+            if (record) return failedOperation(record, error);
+            throw error;
+        }
+    }
+
     async function completeProjection({id}, request) {
         const record = requireProjection(id);
         await record.opening;
@@ -245,7 +331,7 @@ export function createModelAssetService({appRoot = process.cwd()} = {}) {
     }
 
     return {
-        name: 'model-assets', current, retain,
+        name: 'model-assets', current, prepare, retain, release,
         start(serviceContext) { context = serviceContext; },
         methods: {
             'modelAssets.open': openProjection,
@@ -255,8 +341,7 @@ export function createModelAssetService({appRoot = process.cwd()} = {}) {
             'modelAssets.release': {
                 lifetime: 'service',
                 handle({id}) {
-                    const record = projections.get(id);
-                    return record ? releasePreparation(record) : {id, state: 'released'};
+                    return release(id);
                 }
             }
         },