arcane-os 0.2.3 → 0.3.1

package/runtime/arcane/modules/LocalAIReadinessController.js

@@ -2,9 +2,28 @@ import {
     checkLocalAIReadiness,
     deriveLocalAIRequirements
 } from './LocalAIReadiness.js?v=4';
+import {
+    createArcaneEventSource,
+    projectArcaneDOMEvent
+} from 'arcane-os/event-manager';
 
 const SLOT_NAMES=Object.freeze(['llm','stt','tts']);
 
+export const LOCAL_AI_READINESS_CONTROLLER_EVENT_TYPES=Object.freeze({
+    changed:'local-ai-readiness-change'
+});
+export const LOCAL_AI_READINESS_CONTROLLER_ERROR_CODES=Object.freeze({
+    aborted:'ARCANE_LOCAL_AI_READINESS_CONTROLLER_ABORTED',
+    disposed:'ARCANE_LOCAL_AI_READINESS_CONTROLLER_DISPOSED',
+    statusReadyTimeout:'ARCANE_LOCAL_AI_STATUS_COMPONENT_READY_TIMEOUT'
+});
+export const LOCAL_AI_READINESS_CONTROLLER_REASONS=Object.freeze({
+    checked:'local-ai-readiness-checked',
+    aborted:'local-ai-readiness-controller-aborted',
+    disposed:'local-ai-readiness-controller-disposed',
+    statusReadyTimeout:'local-ai-status-component-ready-timeout'
+});
+
 function availabilityFromReport(report={}){
     const slots=report.slots||{};
     return Object.freeze(Object.fromEntries(SLOT_NAMES.map(name=>{
@@ -29,19 +48,85 @@ function pendingReport(requirements){
     });
 }
 
-async function waitForStatusComponent(status){
+function localAIReadinessAbortError(reason,disposed=false){
+    const code=disposed
+        ?LOCAL_AI_READINESS_CONTROLLER_ERROR_CODES.disposed
+        :LOCAL_AI_READINESS_CONTROLLER_ERROR_CODES.aborted;
+    const errorReason=disposed
+        ?LOCAL_AI_READINESS_CONTROLLER_REASONS.disposed
+        :LOCAL_AI_READINESS_CONTROLLER_REASONS.aborted;
+    if(reason instanceof Error
+        &&reason.name==='AbortError'
+        &&reason.code===code
+        &&reason.reason===errorReason){
+        return reason;
+    }
+
+    const error=new Error(
+        disposed
+            ?'The local AI readiness controller has been disposed.'
+            :'The local AI readiness check was aborted.'
+    );
+    error.name='AbortError';
+    error.code=code;
+    error.reason=errorReason;
+    if(reason!==undefined){
+        error.cause=reason;
+    }
+    return error;
+}
+
+async function waitForStatusComponent(status,signal){
     if(!status||status.ready){
         return status;
     }
 
-    await new Promise(resolve=>{
-        const timeout=globalThis.setTimeout(done,10000);
-        function done(){
+    await new Promise(function waitForLocalAIStatusPromise(resolve,reject){
+        let settled=false;
+        const timeout=globalThis.setTimeout(failTimeout,10000);
+
+        function cleanup(){
             globalThis.clearTimeout(timeout);
-            status.removeEventListener('local-ai-status-ready',done);
+            status.removeEventListener('local-ai-status-ready',complete);
+            signal?.removeEventListener('abort',abortWait);
+        }
+
+        function complete(){
+            if(settled){
+                return;
+            }
+            settled=true;
+            cleanup();
             resolve();
         }
-        status.addEventListener('local-ai-status-ready',done,{once:true});
+
+        function fail(error){
+            if(settled){
+                return;
+            }
+            settled=true;
+            cleanup();
+            reject(error);
+        }
+
+        function failTimeout(){
+            const error=new Error('Local AI status component readiness timed out after 10000 ms.');
+            error.code=LOCAL_AI_READINESS_CONTROLLER_ERROR_CODES.statusReadyTimeout;
+            error.reason=LOCAL_AI_READINESS_CONTROLLER_REASONS.statusReadyTimeout;
+            fail(error);
+        }
+
+        function abortWait(){
+            fail(localAIReadinessAbortError(signal?.reason));
+        }
+
+        if(signal?.aborted){
+            abortWait();
+            return;
+        }
+
+        signal?.addEventListener('abort',abortWait,{once:true});
+        status.addEventListener('local-ai-status-ready',complete,{once:true});
     });
     return status;
 }
@@ -62,35 +147,76 @@ export function createLocalAIReadinessController({
         throw new TypeError('A chat component is required.');
     }
 
+    const lifecycleController=new AbortController();
+    const eventOwner=Object.freeze({kind:'local-ai-readiness-controller'});
+    const events=createArcaneEventSource(
+        eventOwner,
+        {
+            source:'local-ai-readiness-controller',
+            eventTypes:Object.freeze(
+                Object.values(LOCAL_AI_READINESS_CONTROLLER_EVENT_TYPES)
+            )
+        }
+    );
     let active=null;
+    let chatReadyListenerPending=false;
+    let destroyed=false;
     let latestReport=null;
     let currentAvailability=availabilityFromReport({});
+    let operationSequence=0;
 
-    const publishAvailability=()=>{
+    function publishAvailability(){
+        if(destroyed){
+            return;
+        }
         if(typeof chat.setAIAvailability==='function'){
+            if(chatReadyListenerPending){
+                chat.removeEventListener('chat-ready',publishAvailability);
+            }
+            chatReadyListenerPending=false;
             chat.setAIAvailability(currentAvailability);
-        }else{
-            chat.addEventListener('chat-ready',publishAvailability,{once:true});
+        }else if(!chatReadyListenerPending){
+            chatReadyListenerPending=true;
+            chat.addEventListener(
+                'chat-ready',
+                publishAvailability,
+                {
+                    once:true,
+                    signal:lifecycleController.signal
+                }
+            );
         }
-    };
+    }
 
-    const applyAvailability=report=>{
+    function applyAvailability(report){
         currentAvailability=availabilityFromReport(report);
         publishAvailability();
-    };
+    }
 
-    const check=async()=>{
+    async function check(){
+        if(destroyed){
+            throw localAIReadinessAbortError(
+                lifecycleController.signal.reason,
+                true
+            );
+        }
         if(active){
             return active;
         }
 
-        active=(async()=>{
+        active=(async function runLocalAIReadinessCheck(){
             const preferenceTuple=selectedPreferences(preferences);
             const requirements=deriveLocalAIRequirements(preferenceTuple);
             const required=SLOT_NAMES.some(name=>requirements[name].required);
 
             applyAvailability(pendingReport(requirements));
-            await waitForStatusComponent(status);
+            await waitForStatusComponent(status,lifecycleController.signal);
+            if(destroyed){
+                throw localAIReadinessAbortError(
+                    lifecycleController.signal.reason,
+                    true
+                );
+            }
             status?.configure?.({profileHref});
             if(required){
                 status?.begin?.(requirements);
@@ -102,42 +228,95 @@ export function createLocalAIReadinessController({
                 ...checkOptions,
                 preferences:preferenceTuple
             });
+            if(destroyed){
+                throw localAIReadinessAbortError(
+                    lifecycleController.signal.reason,
+                    true
+                );
+            }
             status?.present?.(latestReport);
             applyAvailability(latestReport);
             if(typeof onChange==='function'){
                 onChange(latestReport);
             }
-            chat.dispatchEvent(new CustomEvent('local-ai-readiness-change',{
-                bubbles:true,
-                composed:true,
-                detail:{report:latestReport}
-            }));
+            const availability=availabilityFromReport(latestReport);
+            if(destroyed){
+                throw localAIReadinessAbortError(
+                    lifecycleController.signal.reason,
+                    true
+                );
+            }
+            operationSequence+=1;
+            const operationId=`${events.instanceId}:check:${operationSequence.toString(36)}`;
+            const reason=LOCAL_AI_READINESS_CONTROLLER_REASONS.checked;
+            const publication=events.dispatch(
+                LOCAL_AI_READINESS_CONTROLLER_EVENT_TYPES.changed,
+                Object.freeze({operationId,reason,report:latestReport}),
+                {
+                    operationId,
+                    publicDetail:Object.freeze({availability,reason})
+                }
+            );
+            projectArcaneDOMEvent(
+                chat,
+                publication.occurrence,
+                {
+                    bubbles:true,
+                    composed:true
+                }
+            );
             return latestReport;
-        })().finally(()=>{
+        })().finally(function releaseLocalAIReadinessCheck(){
             active=null;
         });
 
         return active;
-    };
+    }
 
-    const ensure=()=>{
+    function ensure(){
         if(active){
             return active;
         }
         return latestReport
             ?Promise.resolve(latestReport)
             :check();
-    };
+    }
+
+    function retry(){
+        void check().catch(function ignoreDestroyedLocalAIRetry(error){
+            if(error?.name!=='AbortError'){
+                console.error('Local AI readiness retry failed.',error);
+            }
+        });
+    }
+    status?.addEventListener(
+        'local-ai-retry',
+        retry,
+        {signal:lifecycleController.signal}
+    );
 
-    const retry=()=>void check();
-    status?.addEventListener('local-ai-retry',retry);
+    function destroy(){
+        if(destroyed){
+            return false;
+        }
+        destroyed=true;
+        lifecycleController.abort(
+            localAIReadinessAbortError(undefined,true)
+        );
+        if(chatReadyListenerPending){
+            chat.removeEventListener('chat-ready',publishAvailability);
+            chatReadyListenerPending=false;
+        }
+        status?.removeEventListener('local-ai-retry',retry);
+        events.dispose();
+        return true;
+    }
 
     return Object.freeze({
         check,
         ensure,
-        destroy(){
-            status?.removeEventListener('local-ai-retry',retry);
-        },
+        destroy,
+        dispose:destroy,
         get availability(){
             return currentAvailability;
         },