arcane-os 0.56.0 → 0.58.0

package/src/local-ai/onnx.mjs

@@ -0,0 +1,368 @@
+import {Worker} from 'node:worker_threads';
+import Is from 'strong-type';
+import {createArcaneEventSource} from '../event-manager.mjs';
+import {createEventQueue} from '../event-queue.mjs';
+
+const is=new Is(false);
+
+function failure(code,message,cause){
+    const error=new Error(message,{cause});
+    error.code=code;
+    return error;
+}
+
+function cancelled(reason){
+    const error=failure('ARCANE_CANCELLED','The ONNX operation was cancelled.',reason);
+    error.name='AbortError';
+    return error;
+}
+
+function describeError(error){
+    if(!(error instanceof Error))return {name:'Error',message:String(error),cause:error};
+    const result={...error,name:error.name,message:error.message,stack:error.stack};
+    if(error.cause!==undefined)result.cause=error.cause instanceof Error?describeError(error.cause):error.cause;
+    if(error instanceof AggregateError)result.errors=error.errors.map(describeError);
+    return result;
+}
+
+function restoreError(record){
+    return Object.assign(new Error(record.message,{cause:record.cause}),record);
+}
+
+function reportBackgroundError(error){
+    if(is.function(globalThis.reportError))globalThis.reportError(error);
+    else console.error(error);
+}
+
+function waitForRelease(task,signal){
+    if(!signal)return task;
+    if(signal.aborted)return Promise.reject(cancelled(signal.reason));
+    return new Promise(function joinRelease(resolve,reject){
+        function abort(){reject(cancelled(signal.reason));}
+        function complete(result){signal.removeEventListener('abort',abort);resolve(result);}
+        function failed(error){signal.removeEventListener('abort',abort);reject(error);}
+        signal.addEventListener('abort',abort,{once:true});
+        void task.then(complete,failed);
+    });
+}
+
+export function createONNXRuntime({modulePath,onEvent,signal}={}){
+    const owner={};
+    const events=createArcaneEventSource(owner,{source:'local-ai.onnx',eventTypes:['onnx.state']});
+    const diagnosticFailures=[];
+    const diagnostics=createEventQueue(deliverDiagnostic,{onFailure:reportBackgroundError});
+    const sessions=new Map();
+    let nextRequestId=0;
+    let closing=false;
+    let closed=false;
+    let closeTask;
+
+    async function deliverDiagnostic(event){
+        if(is.function(onEvent)){
+            try{await onEvent(event);return;}
+            catch(error){diagnosticFailures.push(error);reportBackgroundError(error);}
+        }
+        if(event.type==='local-ai.onnx.stdout'||event.type==='local-ai.onnx.stderr'){
+            process.stderr.write(event.message);
+        }
+    }
+
+    function captureOutput(entry,stream,type){
+        const ended=new Promise(function outputEnded(resolve){
+            stream.once('end',resolve);
+            stream.once('close',resolve);
+            stream.once('error',resolve);
+        });
+        stream.setEncoding('utf8');
+        stream.on('data',function workerOutput(content){
+            stream.pause();
+            void diagnostics.enqueue({type,message:content,data:{id:entry.state.id}}).then(
+                function outputDelivered(){stream.resume();},
+                function outputDeliveryFailed(error){
+                    diagnosticFailures.push(error);
+                    reportBackgroundError(error);
+                    process.stderr.write(content);
+                    stream.resume();
+                }
+            );
+        });
+        stream.on('error',function workerOutputError(error){
+            diagnosticFailures.push(error);
+            reportBackgroundError(error);
+        });
+        return ended;
+    }
+
+    function current(){
+        return {sessions:[...sessions.values()].map(function sessionState(entry){
+            return structuredClone(entry.state);
+        }),closed};
+    }
+
+    function publish(entry){
+        const state=current();
+        events.dispatch('onnx.state',state);
+        diagnostics.enqueue({
+            type:'local-ai.onnx.state',
+            message:entry?`ONNX session ${entry.state.id} is ${entry.state.state}.`:'The ONNX runtime is closed.',
+            data:entry?structuredClone(entry.state):state
+        });
+    }
+
+    function setState(entry,state,loaded,error=null){
+        entry.state={...entry.state,state,loaded,error:error?describeError(error):null};
+        publish(entry);
+    }
+
+    function subscribe(listener){
+        if(!is.function(listener))throw new TypeError('An ONNX state listener must be a function.');
+        if(closed){
+            listener(current());
+            return function unsubscribeClosedRuntime(){};
+        }
+        const unsubscribe=events.on('onnx.state',function deliverState(event){listener(event.detail);});
+        try{listener(current());}
+        catch(error){unsubscribe();throw error;}
+        return unsubscribe;
+    }
+
+    function assertOpen(operationSignal){
+        if(operationSignal?.aborted)throw cancelled(operationSignal.reason);
+        if(closing||closed)throw failure('LOCAL_AI_RUNTIME_CLOSED','The ONNX runtime is closing or closed.');
+    }
+
+    function settle(entry,operation,error,result){
+        if(operation.settled)return;
+        operation.settled=true;
+        operation.signal?.removeEventListener('abort',operation.cancel);
+        if(entry.active===operation)entry.active=null;
+        if(error)operation.reject(error);
+        else operation.resolve(result);
+    }
+
+    function rejectOperations(entry,error){
+        if(entry.active)settle(entry,entry.active,error);
+        for(const operation of entry.queue.splice(0))settle(entry,operation,error);
+    }
+
+    function observeStop(entry,reason,failed=false){
+        void stopSession(entry,reason,failed).catch(reportBackgroundError);
+    }
+
+    function stopSession(entry,reason,failed=false){
+        if(entry.stopTask)return entry.stopTask;
+        if(entry.exited)return Promise.resolve(structuredClone(entry.state));
+        const active=Boolean(entry.active);
+        const worker=entry.worker;
+        entry.stopping=true;
+        if(failed)entry.terminalError??=reason;
+        entry.stopTask=Promise.resolve().then(async function releaseSession(){
+            if(active||failed||entry.terminalError){
+                entry.terminationRequested=true;
+                await worker.terminate();
+            }else{
+                try{worker.postMessage({operation:'unload',requestId:++nextRequestId});}
+                catch(error){
+                    entry.releaseError=error;
+                    entry.terminationRequested=true;
+                    await worker.terminate();
+                }
+            }
+            await entry.exit;
+            await Promise.all(entry.outputTasks);
+            if(entry.releaseError)throw entry.releaseError;
+            return structuredClone(entry.state);
+        });
+        // A native call has no AbortSignal. Stop delivery immediately, retain
+        // unloading state, and join actual worker exit before reporting release.
+        rejectOperations(entry,reason);
+        setState(entry,entry.terminalError?'error':'unloading',entry.state.loaded,entry.terminalError);
+        return entry.stopTask;
+    }
+
+    function dispatchNext(entry){
+        if(closing||entry.stopping||entry.exited||entry.active)return;
+        const operation=entry.queue.shift();
+        if(!operation)return;
+        if(operation.signal?.aborted){
+            settle(entry,operation,cancelled(operation.signal.reason));
+            dispatchNext(entry);
+            return;
+        }
+        entry.active=operation;
+        try{
+            entry.worker.postMessage({requestId:operation.requestId,operation:operation.kind,...operation.payload});
+        }catch(error){
+            if(operation.kind==='load')observeStop(entry,error,true);
+            else{
+                settle(entry,operation,error);
+                setState(entry,'error',entry.state.loaded,error);
+                dispatchNext(entry);
+            }
+        }
+    }
+
+    function enqueue(entry,kind,payload,operationSignal,deferred=false){
+        return new Promise(function queueOperation(resolve,reject){
+            const operation={kind,payload,signal:operationSignal,requestId:++nextRequestId,resolve,reject,settled:false,cancel};
+            function cancel(){
+                if(operation.settled)return;
+                const error=cancelled(operationSignal.reason);
+                if(entry.active===operation||kind==='load')observeStop(entry,error);
+                else{
+                    const index=entry.queue.indexOf(operation);
+                    if(index>=0)entry.queue.splice(index,1);
+                    settle(entry,operation,error);
+                }
+            }
+            entry.queue.push(operation);
+            operationSignal?.addEventListener('abort',cancel,{once:true});
+            if(operationSignal?.aborted)cancel();
+            if(!deferred)dispatchNext(entry);
+        });
+    }
+
+    function receiveResult(entry,message){
+        if(message.operation==='unload'){
+            if(message.error)entry.releaseError=restoreError(message.error);
+            return;
+        }
+        if(closing||entry.stopping||entry.exited)return;
+        const operation=entry.active;
+        if(!operation||operation.requestId!==message.requestId)return;
+        if(operation.signal?.aborted){operation.cancel();return;}
+        if(message.error){
+            const error=restoreError(message.error);
+            if(operation.kind==='load')observeStop(entry,error,true);
+            else{
+                settle(entry,operation,error);
+                setState(entry,'error',true,error);
+                dispatchNext(entry);
+            }
+            return;
+        }
+        if(operation.kind==='load'){
+            entry.state={...entry.state,...message.result};
+            setState(entry,'ready',true);
+        }else if(entry.state.state==='error')setState(entry,'ready',true);
+        if(closing||entry.stopping||operation.settled)return;
+        settle(entry,operation,null,operation.kind==='load'?structuredClone(entry.state):message.result);
+        dispatchNext(entry);
+    }
+
+    function workerExited(entry,code){
+        entry.exited=true;
+        entry.worker=null;
+        if(!entry.stopping||(!entry.terminationRequested&&code!==0)){
+            entry.terminalError??=failure('LOCAL_AI_WORKER_EXITED',`The ONNX worker exited unexpectedly with code ${code}.`);
+            rejectOperations(entry,entry.terminalError);
+        }
+        const error=entry.releaseError??entry.terminalError;
+        try{setState(entry,error?'error':'unloaded',false,error);}
+        finally{entry.resolveExit(code);}
+    }
+
+    async function load({id,model,sessionOptions,signal:operationSignal}={}){
+        assertOpen(operationSignal);
+        if(!is.string(id)||!is.string(model))throw new TypeError('ONNX load requires a session id and model path.');
+        const previous=sessions.get(id);
+        if(previous?.stopTask){
+            try{await waitForRelease(previous.stopTask,operationSignal);}
+            catch(error){
+                // The previous operation retains its release failure. A new
+                // explicit load can proceed once its worker has actually exited.
+                if(operationSignal?.aborted||!previous.exited)throw error;
+            }
+        }
+        assertOpen(operationSignal);
+        if(sessions.get(id)!==previous){
+            throw failure('LOCAL_AI_SESSION_EXISTS',`ONNX session ${String(id)} was loaded by another request.`);
+        }
+        if(previous&&!previous.exited){
+            throw failure('LOCAL_AI_SESSION_EXISTS',`ONNX session ${String(id)} already exists. Unload it before loading a replacement.`);
+        }
+        const entry={
+            state:{id,model,state:'loading',loaded:false,error:null,inputNames:[],outputNames:[],inputMetadata:[],outputMetadata:[]},
+            worker:null,active:null,queue:[],stopping:false,exited:false,stopTask:null,terminalError:null,releaseError:null,terminationRequested:false,outputTasks:[]
+        };
+        entry.exit=new Promise(function workerExit(resolve){entry.resolveExit=resolve;});
+        sessions.set(id,entry);
+        try{
+            entry.worker=new Worker(new URL('./onnx-worker.mjs',import.meta.url),{
+                workerData:{modulePath},stdout:true,stderr:true
+            });
+            entry.outputTasks.push(
+                captureOutput(entry,entry.worker.stdout,'local-ai.onnx.stdout'),
+                captureOutput(entry,entry.worker.stderr,'local-ai.onnx.stderr')
+            );
+            entry.worker.on('message',function workerMessage(message){receiveResult(entry,message);});
+            entry.worker.on('messageerror',function workerMessageError(error){observeStop(entry,error,true);});
+            entry.worker.on('error',function workerError(error){
+                entry.terminalError=error;
+                entry.stopping=true;
+                rejectOperations(entry,error);
+                setState(entry,'error',entry.state.loaded,error);
+            });
+            entry.worker.once('exit',function workerExit(code){workerExited(entry,code);});
+        }catch(error){
+            entry.exited=true;
+            setState(entry,'error',false,error);
+            entry.resolveExit(null);
+            throw error;
+        }
+        // Queue load before publishing readiness so a synchronous subscriber
+        // can enqueue inference or request release without racing ownership.
+        const task=enqueue(entry,'load',{model,sessionOptions},operationSignal,true);
+        publish(entry);
+        dispatchNext(entry);
+        return task;
+    }
+
+    async function run({id,feeds,fetches,runOptions,signal:operationSignal}={}){
+        assertOpen(operationSignal);
+        const entry=sessions.get(id);
+        if(!entry||entry.exited||entry.stopping){
+            throw failure('LOCAL_AI_SESSION_UNAVAILABLE',`ONNX session ${String(id)} is not loaded or loading.`);
+        }
+        return enqueue(entry,'run',{feeds,fetches,runOptions},operationSignal);
+    }
+
+    async function unload({id,signal:operationSignal}={}){
+        if(operationSignal?.aborted)throw cancelled(operationSignal.reason);
+        const entry=sessions.get(id);
+        if(!entry)throw failure('LOCAL_AI_SESSION_UNAVAILABLE',`ONNX session ${String(id)} does not exist.`);
+        const result=await stopSession(entry,failure('LOCAL_AI_SESSION_UNLOADED',`ONNX session ${String(id)} is unloading.`));
+        if(operationSignal?.aborted)throw cancelled(operationSignal.reason);
+        return result;
+    }
+
+    function close(){
+        if(closeTask)return closeTask;
+        closing=true;
+        signal?.removeEventListener('abort',lifetimeAborted);
+        closeTask=Promise.resolve().then(async function closeRuntime(){
+            const results=await Promise.allSettled([...sessions.values()].map(function releaseEntry(entry){
+                return stopSession(entry,failure('LOCAL_AI_RUNTIME_CLOSED','The ONNX runtime is closing.'));
+            }));
+            await Promise.all([...sessions.values()].filter(function exited(entry){return entry.exited;})
+                .flatMap(function outputs(entry){return entry.outputTasks;}));
+            const failures=results.filter(function rejected(result){return result.status==='rejected';})
+                .map(function rejection(result){return result.reason;});
+            closed=[...sessions.values()].every(function exited(entry){return entry.exited;});
+            if(closed)publish();
+            try{await diagnostics.drain();}
+            catch(error){failures.push(error);}
+            failures.push(...diagnosticFailures);
+            if(closed)events.dispose();
+            if(failures.length)throw new AggregateError(failures,'The ONNX runtime closed with errors.');
+            return current();
+        });
+        return closeTask;
+    }
+
+    function lifetimeAborted(){void close().catch(reportBackgroundError);}
+
+    signal?.addEventListener('abort',lifetimeAborted,{once:true});
+    if(signal?.aborted)lifetimeAborted();
+    return {load,run,unload,current,subscribe,close};
+}

package/src/local-ai/server.mjs

@@ -0,0 +1,262 @@
+import {mkdir} from 'node:fs/promises';
+import path from 'node:path';
+import Is from 'strong-type';
+import {ArcaneError,ERROR_CODES,errorRecord,normalizeError,throwIfAborted} from '../errors.mjs';
+import {createEventQueue} from '../event-queue.mjs';
+import {runProcess} from '../process.mjs';
+
+const is=new Is(false);
+
+export function localAIConnectionRefused(error){
+    if(error?.code==='ECONNREFUSED'||error?.cause?.code==='ECONNREFUSED')return true;
+    const failures=error?.errors??error?.cause?.errors;
+    return is.array(failures)&&failures.length>0&&failures.every(localAIConnectionRefused);
+}
+
+function localHostname(hostname){
+    return hostname==='localhost'||hostname==='127.0.0.1'||hostname==='[::1]'||hostname==='::1';
+}
+
+export function localAIServerURL(id,configuration={}){
+    return configuration.url??(id==='llama.cpp'?'http://127.0.0.1:8080':'http://127.0.0.1:11434');
+}
+
+export async function inspectLocalAIServer({id,url,signal}){
+    throwIfAborted(signal);
+    const endpoint=new URL(id==='llama.cpp'?'/health':'/api/version',url);
+    const response=await fetch(endpoint,{signal});
+    const content=await response.text();
+    throwIfAborted(signal);
+    let result=null;
+    try{
+        result=JSON.parse(content);
+    }catch(error){
+        if(!(error instanceof SyntaxError))throw error;
+    }
+    const ready=response.ok&&(id==='llama.cpp'?result?.status==='ok':is.string(result?.version)&&Boolean(result.version));
+    return {url,status:response.status,ready,version:id==='ollama'&&is.string(result?.version)?result.version:undefined,content,result};
+}
+
+async function probeServer(id,url,signal){
+    const observed=await inspectLocalAIServer({id,url,signal});
+    if(!observed.ready){
+        if(id==='llama.cpp'&&observed.status===503&&observed.result?.error?.message==='Loading model'){
+            throw new ArcaneError('LOCAL_AI_LOADING','llama.cpp is loading its model.',{details:observed});
+        }
+        throw new ArcaneError(ERROR_CODES.operationFailed,`${id} readiness returned HTTP ${observed.status}: ${observed.content}`,{details:observed});
+    }
+    return observed;
+}
+
+export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,onEvent,onState}={}){
+    if(!['llama.cpp','ollama'].includes(id)){
+        throw new ArcaneError(ERROR_CODES.usage,`Unsupported local AI server: ${String(id)}.`);
+    }
+    const url=localAIServerURL(id,configuration);
+    const endpoint=new URL(url);
+    const controller=new AbortController();
+    const operationSignal=signal?AbortSignal.any([signal,controller.signal]):controller.signal;
+    const events=createEventQueue(onEvent,{onFailure:fail});
+    let current={id,url,state:'starting',available:false,owned:false};
+    let owned=false;
+    let processTask=null;
+    let processObservation=null;
+    let startupTask=null;
+    let closeTask=null;
+    let closing=false;
+    let settled=false;
+    let readinessStarted=false;
+    let readinessTask=null;
+    let terminalFailure=null;
+    let resolveReady;
+    let rejectReady;
+    const output={stdout:'',stderr:''};
+    const ready=new Promise(function createReadiness(resolve,reject){
+        resolveReady=resolve;
+        rejectReady=reject;
+    });
+    // Readiness remains returned to the caller; this observer prevents a
+    // background start from creating an unhandled rejection before it is used.
+    void ready.catch(function observeReadinessFailure(){return undefined;});
+
+    async function publishState(state,error){
+        current={id,url,state,available:state==='ready',owned,...(error?{error:errorRecord(error)}:{})};
+        await onState?.(current);
+        await events.send({
+            type:`local-ai.server.${state}`,
+            message:error?`${id}: ${error.message}`:`${id} is ${state}.`,
+            data:{...current,...(error?{error}:{})}
+        });
+    }
+
+    function settleReady(error){
+        if(settled)return;
+        settled=true;
+        if(error)rejectReady(error);
+        else resolveReady(current);
+    }
+
+    async function fail(error){
+        const failure=normalizeError(error);
+        terminalFailure??=failure;
+        controller.abort(failure);
+        settleReady(failure);
+        try{
+            const state=closing?'stopped':failure.code==='LOCAL_AI_LOADING'?'loading':'error';
+            await publishState(state,state==='error'?failure:undefined);
+        }catch(observerError){
+            // Keep the callback failure visible on the returned observation;
+            // the operation's original failure remains on the ready Promise.
+            current={...current,available:false,error:errorRecord(observerError)};
+            throw observerError;
+        }
+    }
+
+    async function confirmReadiness(){
+        await probeServer(id,url,operationSignal);
+        throwIfAborted(operationSignal);
+        await publishState('ready');
+        throwIfAborted(operationSignal);
+        settleReady();
+    }
+
+    async function forwardProcessEvent(event){
+        await events.send(event);
+        if(readinessStarted||closing||operationSignal.aborted)return;
+        if(event.type==='process.stdout')output.stdout+=event.data?.line??event.message;
+        else if(event.type==='process.stderr')output.stderr+=event.data?.line??event.message;
+        else return;
+        const text=event.type==='process.stdout'?output.stdout:output.stderr;
+        // llama.cpp b11146 and b6000 emit these after HTTP/model readiness;
+        // Ollama emits its listener announcement before serving queued requests.
+        const announced=id==='llama.cpp'?/\b(?:llama_server:\s*listening on |main:\s*server is listening on )/u.test(text):/Listening on /u.test(text);
+        if(!announced)return;
+        readinessStarted=true;
+        // Do not hold the process-output callback while the health response
+        // waits for upstream startup; stdout/stderr must continue draining.
+        readinessTask=confirmReadiness().catch(fail);
+        void readinessTask.catch(function observeReadinessCallbackFailure(){return undefined;});
+    }
+
+    async function start(){
+        await publishState('starting');
+        throwIfAborted(operationSignal);
+        let existing=false;
+        try{
+            // Discovery may precede another runtime's installation. Read the
+            // endpoint at this actual launch boundary rather than presenting
+            // that earlier installation-selection snapshot as current health.
+            const observed=await probeServer(id,url,operationSignal);
+            if(runtime?.requestedVersion&&runtime.requestedVersion!=='latest'){
+                const requested=runtime.requestedVersion.replace(/^v/u,'');
+                if(!is.string(observed.version)||observed.version.replace(/^v/u,'')!==requested){
+                    throw new ArcaneError(ERROR_CODES.operationFailed,`The running ${id} service does not establish the requested version ${runtime.requestedVersion}. Select an available listener for that installed runtime.`,{details:observed});
+                }
+            }
+            existing=true;
+        }catch(error){
+            throwIfAborted(operationSignal);
+            // An HTTP error is an existing service's state. Only a refused
+            // connection allows starting the selected local executable.
+            if(!localAIConnectionRefused(error))throw error;
+            if(!localHostname(endpoint.hostname))throw error;
+        }
+        if(existing){
+            await publishState('ready');
+            throwIfAborted(operationSignal);
+            settleReady();
+            return;
+        }
+        if(!runtime?.executable){
+            throw new ArcaneError(ERROR_CODES.prerequisiteMissing,`No installed ${id} executable was supplied.`);
+        }
+        if(endpoint.protocol!=='http:'){
+            throw new ArcaneError(ERROR_CODES.usage,`${id} managed startup requires its direct HTTP listener URL.`);
+        }
+        if(!is.string(appRoot)||!appRoot){
+            throw new ArcaneError(ERROR_CODES.usage,`${id} managed startup needs its application root.`);
+        }
+        const args=configuration.args??[];
+        if(!is.array(args)||args.some(function nonStringArgument(argument){
+            return !is.string(argument);
+        })){
+            throw new ArcaneError(ERROR_CODES.usage,`${id} arguments must be an array of strings.`);
+        }
+        const modelsDirectory=path.resolve(appRoot,configuration.modelsDirectory??path.join('.arcane','models',id));
+        await mkdir(modelsDirectory,{recursive:true});
+        throwIfAborted(operationSignal);
+        const host=endpoint.hostname.replace(/^\[|\]$/gu,'');
+        const port=endpoint.port||'80';
+        const arguments_=id==='ollama'?['serve',...args]:[
+            '--host',host,'--port',port,'--jinja',
+            ...(configuration.model?['--model',path.resolve(appRoot,configuration.model)]:['--models-dir',modelsDirectory]),
+            ...args
+        ];
+        const env=id==='ollama'?{OLLAMA_HOST:endpoint.origin,OLLAMA_MODELS:modelsDirectory}:undefined;
+        owned=true;
+        await publishState('starting');
+        throwIfAborted(operationSignal);
+        processTask=runProcess(runtime.executable,arguments_,{
+            cwd:path.dirname(runtime.executable),env,signal:operationSignal,onEvent:forwardProcessEvent
+        });
+        processObservation=processTask.then(async function localServerExited(result){
+            if(terminalFailure)return;
+            if(closing||operationSignal.aborted){
+                settleReady(new ArcaneError(ERROR_CODES.cancelled,`${id} startup was cancelled.`,{exitCode:130}));
+                await publishState('stopped');
+                return;
+            }
+            await fail(new ArcaneError(ERROR_CODES.operationFailed,`${id} stopped with exit code ${result.code}.`,{details:result}));
+        },async function localServerFailed(error){
+            if(terminalFailure)return;
+            if(closing||(signal?.aborted&&!events.error)){
+                settleReady(normalizeError(error));
+                await publishState('stopped');
+                return;
+            }
+            await fail(error);
+        });
+        void processObservation.catch(function observeProcessCallbackFailure(error){
+            current={...current,state:'error',available:false,error:errorRecord(error)};
+            settleReady(error);
+        });
+    }
+
+    async function finishClose(){
+        closing=true;
+        operationSignal.removeEventListener('abort',observeLifetimeAbort);
+        controller.abort(new ArcaneError(ERROR_CODES.cancelled,`${id} was stopped by its owner.`,{exitCode:130}));
+        const startup=await Promise.allSettled([startupTask]);
+        const tasks=[processObservation,readinessTask].filter(function activeTask(task){return task!==null;});
+        const outcomes=await Promise.allSettled(tasks);
+        settleReady(new ArcaneError(ERROR_CODES.cancelled,`${id} startup was cancelled.`,{exitCode:130}));
+        await publishState('stopped');
+        await events.drain();
+        const failures=[...startup,...outcomes].filter(function failedTask(outcome){return outcome.status==='rejected';});
+        if(failures.length===1)throw failures[0].reason;
+        if(failures.length>1)throw new AggregateError(failures.map(function taskFailure(outcome){return outcome.reason;}),`${id} shutdown observers failed.`);
+    }
+
+    function close(){
+        closeTask??=finishClose();
+        return closeTask;
+    }
+
+    function observeLifetimeAbort(){
+        if(closing||terminalFailure)return;
+        void close().catch(function observeAbortShutdownFailure(error){
+            current={...current,state:'error',available:false,error:errorRecord(error)};
+            settleReady(error);
+        });
+    }
+
+    startupTask=start().catch(fail);
+    void startupTask.catch(function observeStartupCallbackFailure(error){
+        current={...current,state:'error',available:false,error:errorRecord(error)};
+        settleReady(error);
+    });
+    operationSignal.addEventListener('abort',observeLifetimeAbort,{once:true});
+    if(operationSignal.aborted)observeLifetimeAbort();
+
+    return {ready,url,close,get owned(){return owned;},get current(){return current;}};
+}