arcane-os 0.2.2 → 0.3.0

package/runtime/arcane/modules/AIRuntimeState.js

@@ -1,3 +1,5 @@
+import {createArcaneEventSource} from 'arcane-os/event-manager';
+
 export const AI_RUNTIME_PROTOCOL = 'arcane-ai-runtime-state/1';
 export const AI_RUNTIME_STATE_EVENT = 'arcane-ai-runtime-state';
 export const AI_RUNTIME_INTENT_EVENT = 'arcane-ai-runtime-intent';
@@ -87,7 +89,34 @@ const MAX_IDENTIFIER_LENGTH = 128;
 const MAX_PROGRESS_UNIT_LENGTH = 32;
 const MAX_ERROR_MESSAGE_LENGTH = 512;
 
-export const aiRuntimeEvents = new EventTarget();
+/**
+ * @deprecated Subscribe through the focused runtime helpers or arcaneEvents.
+ * This state-free EventTarget compatibility view delegates to the module's
+ * canonical source; it does not own a second listener registry or event bus.
+ */
+const aiRuntimeEventCompatibilityView = {
+    addEventListener(type, listener, options) {
+        return aiRuntimeEventSource.addEventListener(type, listener, options);
+    },
+    removeEventListener(type, listener, options) {
+        return aiRuntimeEventSource.removeEventListener(type, listener, options);
+    },
+    dispatchEvent(event) {
+        return aiRuntimeEventSource.dispatchEvent(event);
+    }
+};
+const aiRuntimeEventSource = createArcaneEventSource(
+    aiRuntimeEventCompatibilityView,
+    {
+        source: 'ai-runtime-state',
+        eventTypes: Object.freeze([
+            AI_RUNTIME_STATE_EVENT,
+            AI_RUNTIME_INTENT_EVENT,
+            AI_RUNTIME_STARTUP_EVENT
+        ])
+    }
+);
+export const aiRuntimeEvents = Object.freeze(aiRuntimeEventCompatibilityView);
 
 function fail(message) {
     throw new TypeError(`ARCANE_AI_RUNTIME_STATE_INVALID: ${message}`);
@@ -316,6 +345,50 @@ function unavailableRole(role) {
     );
 }
 
+function publicAIRuntimeState(snapshot, role = null) {
+    const roleState = role === null ? null : snapshot.roles[role];
+    return Object.freeze(
+        {
+            revision: snapshot.revision,
+            ...(roleState
+                ? {
+                    role,
+                    state: roleState.state,
+                    ...(roleState.operationId === null
+                        ? {}
+                        : {operationId: roleState.operationId}),
+                    ...(roleState.progress === null
+                        ? {}
+                        : {progress: roleState.progress}),
+                    ...(roleState.error === null
+                        ? {}
+                        : {code: roleState.error.code})
+                }
+                : {count: AI_RUNTIME_ROLES.length})
+        }
+    );
+}
+
+function publicAIRuntimeIntent(intent) {
+    return Object.freeze(
+        {
+            role: intent.role,
+            action: intent.action,
+            reason: intent.reason
+        }
+    );
+}
+
+function publicAIRuntimeStartup(report) {
+    return Object.freeze(
+        {
+            revision: report.currentRevision,
+            role: 'llm',
+            state: report.roles.llm.state.state
+        }
+    );
+}
+
 function initialSnapshot() {
     return Object.freeze(
         {
@@ -503,37 +576,25 @@ function assertListener(listener) {
 
 function subscribe(eventName, listener, normalized, currentValue) {
     assertListener(listener);
-    let active = !normalized.signal?.aborted;
-
-    function unsubscribeAIRuntimeEvent() {
-        if (!active) {
-            return;
-        }
-
-        active = false;
-        aiRuntimeEvents.removeEventListener(eventName, forwardAIRuntimeEvent);
-        normalized.signal?.removeEventListener('abort', unsubscribeAIRuntimeEvent);
-    }
 
     function forwardAIRuntimeEvent(event) {
         listener(event.detail);
     }
 
-    if (!active) {
-        return unsubscribeAIRuntimeEvent;
-    }
-
-    aiRuntimeEvents.addEventListener(eventName, forwardAIRuntimeEvent);
-    normalized.signal?.addEventListener(
-        'abort',
-        unsubscribeAIRuntimeEvent,
-        {
-            once: true
-        }
+    const unsubscribeAIRuntimeEvent = aiRuntimeEventSource.on(
+        eventName,
+        forwardAIRuntimeEvent,
+        normalized.signal
+            ? {
+                signal: normalized.signal
+            }
+            : undefined
     );
 
     try {
-        if (normalized.emitCurrent && currentValue !== undefined) {
+        if (!normalized.signal?.aborted
+            && normalized.emitCurrent
+            && currentValue !== undefined) {
             listener(currentValue);
         }
     } catch (error) {
@@ -587,13 +648,12 @@ export function publishAIRuntimeRoleState(role, completeRecord) {
             roles: Object.freeze(nextRoles)
         }
     );
-    aiRuntimeEvents.dispatchEvent(
-        new CustomEvent(
-            AI_RUNTIME_STATE_EVENT,
-            {
-                detail: currentSnapshot
-            }
-        )
+    aiRuntimeEventSource.dispatch(
+        AI_RUNTIME_STATE_EVENT,
+        currentSnapshot,
+        {
+            publicDetail: publicAIRuntimeState(currentSnapshot, role)
+        }
     );
     return currentSnapshot;
 }
@@ -624,13 +684,12 @@ export function publishAIRuntimeRolesState(completeRecords) {
             roles: nextRoles
         }
     );
-    aiRuntimeEvents.dispatchEvent(
-        new CustomEvent(
-            AI_RUNTIME_STATE_EVENT,
-            {
-                detail: currentSnapshot
-            }
-        )
+    aiRuntimeEventSource.dispatch(
+        AI_RUNTIME_STATE_EVENT,
+        currentSnapshot,
+        {
+            publicDetail: publicAIRuntimeState(currentSnapshot)
+        }
     );
     return currentSnapshot;
 }
@@ -656,13 +715,12 @@ export function requestAIRuntimeIntent(intent) {
             reason: intent.reason
         }
     );
-    aiRuntimeEvents.dispatchEvent(
-        new CustomEvent(
-            AI_RUNTIME_INTENT_EVENT,
-            {
-                detail: publishedIntent
-            }
-        )
+    aiRuntimeEventSource.dispatch(
+        AI_RUNTIME_INTENT_EVENT,
+        publishedIntent,
+        {
+            publicDetail: publicAIRuntimeIntent(publishedIntent)
+        }
     );
     return publishedIntent;
 }
@@ -747,13 +805,12 @@ export function startAIRuntime(options) {
         );
         barrierResolved = true;
         resolveBarrier(report);
-        aiRuntimeEvents.dispatchEvent(
-            new CustomEvent(
-                AI_RUNTIME_STARTUP_EVENT,
-                {
-                    detail: report
-                }
-            )
+        aiRuntimeEventSource.dispatch(
+            AI_RUNTIME_STARTUP_EVENT,
+            report,
+            {
+                publicDetail: publicAIRuntimeStartup(report)
+            }
         );
     }
 

package/runtime/arcane/modules/ApiModelDatabase.js

@@ -1,25 +1,398 @@
+import {createArcaneEventSource} from 'arcane-os/event-manager';
 import ApiModelRecord from '../entities/ApiModelRecord.js';
 
-function event(type,detail){return new CustomEvent(type,{detail});}
-function endpoint(value){const url=new URL(String(value||''));if(!['http:','https:'].includes(url.protocol))throw new TypeError('API model endpoints must use HTTP or HTTPS.');return url.href;}
-function appendParameters(url,parameters={}){for(const [key,value] of Object.entries(parameters||{})){if(value===undefined||value===null||value==='')continue;url.searchParams.set(key,Array.isArray(value)?value.join(','):String(value));}return url;}
-function publicEndpoint(url){const safe=new URL(url);for(const key of [...safe.searchParams.keys()])if(/(?:auth|key|password|secret|token)/i.test(key))safe.searchParams.set(key,'[redacted]');return safe.href;}
+export const API_MODEL_EVENTS=Object.freeze({
+    requestStarted:'api-model-request',
+    requestSucceeded:'api-model-success',
+    requestFailed:'api-model-error'
+});
+
+const API_MODEL_EVENT_TYPES=Object.freeze(Object.values(API_MODEL_EVENTS));
+
+export const API_MODEL_ERRORS=Object.freeze({
+    requestAborted:Object.freeze({code:'ARCANE_API_MODEL_REQUEST_ABORTED',reason:'api-model-request-aborted'}),
+    cacheReadFailed:Object.freeze({code:'ARCANE_API_MODEL_CACHE_READ_FAILED',reason:'api-model-cache-read-rejected'}),
+    cacheWriteFailed:Object.freeze({code:'ARCANE_API_MODEL_CACHE_WRITE_FAILED',reason:'api-model-cache-write-rejected'}),
+    databaseDisposed:Object.freeze({code:'ARCANE_API_MODEL_DATABASE_DISPOSED',reason:'api-model-database-disposed'}),
+    requestFetchFailed:Object.freeze({code:'ARCANE_API_MODEL_REQUEST_FETCH_FAILED',reason:'api-model-request-fetch-rejected'}),
+    requestOptionsInvalid:Object.freeze({code:'ARCANE_API_MODEL_REQUEST_OPTIONS_INVALID',reason:'api-model-request-options-invalid'}),
+    responseContractInvalid:Object.freeze({code:'ARCANE_API_MODEL_RESPONSE_CONTRACT_INVALID',reason:'api-model-response-contract-mismatch'}),
+    responseJSONInvalid:Object.freeze({code:'ARCANE_API_MODEL_RESPONSE_JSON_INVALID',reason:'api-model-response-json-invalid'}),
+    responseParseFailed:Object.freeze({code:'ARCANE_API_MODEL_RESPONSE_PARSE_FAILED',reason:'api-model-response-parse-rejected'}),
+    responseStatusRejected:Object.freeze({code:'ARCANE_API_MODEL_RESPONSE_STATUS_REJECTED',reason:'api-model-response-status-rejected'})
+});
+
+function endpoint(value){
+    const url=new URL(String(value||''));
+    if(!['http:','https:'].includes(url.protocol))throw new TypeError('API model endpoints must use HTTP or HTTPS.');
+    return url.href;
+}
+
+function appendParameters(url,parameters={}){
+    for(const [key,value] of Object.entries(parameters||{})){
+        if(value===undefined||value===null||value==='')continue;
+        url.searchParams.set(key,Array.isArray(value)?value.join(','):String(value));
+    }
+    return url;
+}
+
+function publicEndpoint(url){
+    const safe=new URL(url);
+    for(const key of [...safe.searchParams.keys()]){
+        if(/(?:auth|key|password|secret|token)/i.test(key))safe.searchParams.set(key,'[redacted]');
+    }
+    return safe.href;
+}
+
+function signalLike(value){
+    return value===undefined
+        ||value===null
+        ||(
+            typeof value==='object'
+            &&typeof value.aborted==='boolean'
+            &&typeof value.addEventListener==='function'
+            &&typeof value.removeEventListener==='function'
+        );
+}
+
+function errorMessage(value,fallback){
+    if(typeof value?.message==='string'&&value.message.trim())return value.message;
+    if(typeof value==='string'&&value.trim())return value;
+    return fallback;
+}
+
+function defineErrorContract(error,contract,cause){
+    const priorCode=typeof error?.code==='string'&&error.code?error.code:null;
+    try{
+        if(priorCode&&priorCode!==contract.code&&!Object.hasOwn(error,'providerCode')){
+            Object.defineProperty(error,'providerCode',{configurable:true,enumerable:false,value:priorCode,writable:true});
+        }
+        Object.defineProperty(error,'code',{configurable:true,enumerable:false,value:contract.code,writable:true});
+        Object.defineProperty(error,'reason',{configurable:true,enumerable:false,value:contract.reason,writable:true});
+        if(cause!==undefined&&cause!==error&&!('cause' in error)){
+            Object.defineProperty(error,'cause',{configurable:true,enumerable:false,value:cause,writable:true});
+        }
+        return error;
+    }catch{
+        const replacement=new Error(errorMessage(error,'The API model operation failed.'));
+        replacement.code=contract.code;
+        replacement.reason=contract.reason;
+        if(priorCode&&priorCode!==contract.code)replacement.providerCode=priorCode;
+        if(cause!==undefined)replacement.cause=cause;
+        else if(error!==undefined)replacement.cause=error;
+        return replacement;
+    }
+}
+
+function apiModelError(error,contract,message){
+    const candidate=error&&(typeof error==='object'||typeof error==='function')
+        ?error
+        :new Error(errorMessage(error,message));
+    return defineErrorContract(candidate,contract,error!==candidate?error:undefined);
+}
+
+function disposedError(){
+    return apiModelError(
+        new Error('The API model database has been disposed.'),
+        API_MODEL_ERRORS.databaseDisposed,
+        'The API model database has been disposed.'
+    );
+}
+
+function requestOptions(value){
+    if(value===undefined)return Object.freeze({operationId:null,signal:null});
+    if(!value||typeof value!=='object'||Array.isArray(value)){
+        throw apiModelError(
+            new TypeError('API model request options must be an object.'),
+            API_MODEL_ERRORS.requestOptionsInvalid,
+            'API model request options must be an object.'
+        );
+    }
+    if(!signalLike(value.signal)){
+        throw apiModelError(
+            new TypeError('API model request signal must be an AbortSignal.'),
+            API_MODEL_ERRORS.requestOptionsInvalid,
+            'API model request signal must be an AbortSignal.'
+        );
+    }
+    const operationId=value.operationId??null;
+    if(operationId!==null&&(
+        typeof operationId!=='string'
+        ||operationId.trim()!==operationId
+        ||operationId.length<1
+        ||operationId.length>256
+    )){
+        throw apiModelError(
+            new TypeError('API model operationId must contain 1-256 non-edge-whitespace characters.'),
+            API_MODEL_ERRORS.requestOptionsInvalid,
+            'API model operationId is invalid.'
+        );
+    }
+    return Object.freeze({operationId,signal:value.signal??null});
+}
+
+function linkAbortSignal(signal,controller,cleanup){
+    if(signal===null)return;
+    function abortLinkedOperation(){
+        if(!controller.signal.aborted)controller.abort(signal.reason);
+    }
+    if(signal.aborted){
+        abortLinkedOperation();
+        return;
+    }
+    signal.addEventListener('abort',abortLinkedOperation,{once:true});
+    cleanup.push(function removeLinkedAbortListener(){
+        signal.removeEventListener('abort',abortLinkedOperation);
+    });
+}
+
+function operationError(error,stage,signal){
+    if(signal.aborted){
+        const reason=signal.reason;
+        if(reason
+            &&typeof reason==='object'
+            &&typeof reason.code==='string'
+            &&reason.code
+            &&typeof reason.reason==='string'
+            &&reason.reason)return reason;
+        return apiModelError(reason??error,API_MODEL_ERRORS.requestAborted,'The API model request was aborted.');
+    }
+    if(stage==='fetch')return apiModelError(error,API_MODEL_ERRORS.requestFetchFailed,'The API model request failed.');
+    if(stage==='response')return apiModelError(error,API_MODEL_ERRORS.responseContractInvalid,'The API model response contract is invalid.');
+    if(stage==='response-json')return apiModelError(error,API_MODEL_ERRORS.responseJSONInvalid,'The API model response body is not valid JSON.');
+    if(stage==='response-status')return apiModelError(error,API_MODEL_ERRORS.responseStatusRejected,'The API model response status rejected the request.');
+    if(stage==='response-parse')return apiModelError(error,API_MODEL_ERRORS.responseParseFailed,'The API model response parser failed.');
+    return apiModelError(error,API_MODEL_ERRORS.cacheWriteFailed,'The API model cache write failed.');
+}
 
 export default class ApiModelDatabase extends EventTarget{
-    constructor({endpoint:source,parser=value=>value,fetchImpl=globalThis.fetch,cache=null,request={}}={}){super();this.endpoint=endpoint(source);if(typeof parser!=='function')throw new TypeError('API model parser must be a function.');if(typeof fetchImpl!=='function')throw new TypeError('API model fetch implementation must be a function.');this.parser=parser;this.fetchImpl=fetchImpl;this.cache=cache;this.request={...request};this.latest=null;}
-    setEndpoint(value){this.endpoint=endpoint(value);return this.endpoint;}
-    async fetch(parameters={},context={}){
-        const url=appendParameters(new URL(this.endpoint),parameters);const visibleEndpoint=publicEndpoint(url);const requestId=globalThis.crypto?.randomUUID?.()||`${Date.now()}-${Math.random().toString(16).slice(2)}`;
-        this.dispatchEvent(event('api-model-request',{requestId,endpoint:visibleEndpoint}));
+    #disposed=false;
+    #events;
+    #operationSequence=0;
+    #operations=new Set();
+
+    constructor({endpoint:source,parser=value=>value,fetchImpl=globalThis.fetch,cache=null,request={}}={}){
+        super();
+        this.endpoint=endpoint(source);
+        if(typeof parser!=='function')throw new TypeError('API model parser must be a function.');
+        if(typeof fetchImpl!=='function')throw new TypeError('API model fetch implementation must be a function.');
+        this.parser=parser;
+        this.fetchImpl=fetchImpl;
+        this.cache=cache;
+        this.request={...request};
+        this.latest=null;
+        this.#events=createArcaneEventSource(this,{
+            source:'api-model-database',
+            eventTypes:API_MODEL_EVENT_TYPES
+        });
+    }
+
+    addEventListener(type,listener,options){return this.#events.addEventListener(type,listener,options);}
+    removeEventListener(type,listener,options){return this.#events.removeEventListener(type,listener,options);}
+    on(type,listener,options){return this.#events.on(type,listener,options);}
+    dispatchEvent(value){return this.#events.dispatchEvent(value);}
+
+    #assertOpen(){if(this.#disposed)throw disposedError();}
+
+    #publishError(operation,error){
+        if(operation.errorPublished||this.#events.disposed)return false;
+        operation.errorPublished=true;
+        this.#events.dispatch(
+            API_MODEL_EVENTS.requestFailed,
+            Object.freeze({
+                requestId:operation.operationId,
+                endpoint:operation.visibleEndpoint,
+                error,
+                reason:error.reason
+            }),
+            {
+                operationId:operation.operationId,
+                publicDetail:Object.freeze({code:error.code,reason:error.reason})
+            }
+        );
+        return true;
+    }
+
+    #startOperation(visibleEndpoint,options){
+        const controller=new AbortController();
+        const cleanup=[];
+        const requestSignal=this.request?.signal??null;
+        if(!signalLike(requestSignal)){
+            throw apiModelError(
+                new TypeError('The configured API model request signal must be an AbortSignal.'),
+                API_MODEL_ERRORS.requestOptionsInvalid,
+                'The configured API model request signal must be an AbortSignal.'
+            );
+        }
+        linkAbortSignal(requestSignal,controller,cleanup);
+        if(options.signal!==requestSignal)linkAbortSignal(options.signal,controller,cleanup);
+        const operationId=options.operationId
+            ??`${this.#events.instanceId}:fetch:${(++this.#operationSequence).toString(36)}`;
+        const operation={
+            cleanup,
+            controller,
+            errorPublished:false,
+            operationId,
+            settled:false,
+            terminalError:null,
+            visibleEndpoint
+        };
+        this.#operations.add(operation);
+        return operation;
+    }
+
+    #finishOperation(operation){
+        operation.settled=true;
+        this.#operations.delete(operation);
+        for(const remove of operation.cleanup.splice(0))remove();
+    }
+
+    setEndpoint(value){
+        this.#assertOpen();
+        this.endpoint=endpoint(value);
+        return this.endpoint;
+    }
+
+    async fetch(parameters={},context={},optionsValue={}){
+        this.#assertOpen();
+        const options=requestOptions(optionsValue);
+        const url=appendParameters(new URL(this.endpoint),parameters);
+        const visibleEndpoint=publicEndpoint(url);
+        const operation=this.#startOperation(visibleEndpoint,options);
+        let started=false;
+        let stage='fetch';
         try{
-            const response=await this.fetchImpl(url,{method:'GET',...this.request,headers:{Accept:'application/json',...(this.request.headers||{})}});const raw=await response.json();
-            if(!response.ok)throw new Error(raw?.reason||raw?.error||`API request failed (${response.status}).`);
-            const value=await this.parser(raw,{context,endpoint:url.href,response:{status:response.status,headers:response.headers}});const record=new ApiModelRecord({endpoint:visibleEndpoint,value,metadata:{requestId,status:response.status}});this.latest=record;
-            if(this.cache?.set)await this.cache.set(visibleEndpoint,record.toJSON());
-            this.dispatchEvent(event('api-model-success',{requestId,record}));return record;
-        }catch(error){this.dispatchEvent(event('api-model-error',{requestId,endpoint:visibleEndpoint,error}));throw error;}
-    }
-    async cached(parameters={}){const url=appendParameters(new URL(this.endpoint),parameters);if(!this.cache?.get)return null;const value=await this.cache.get(publicEndpoint(url));return value?new ApiModelRecord(value):null;}
+            if(operation.controller.signal.aborted){
+                throw operationError(operation.controller.signal.reason,stage,operation.controller.signal);
+            }
+            started=true;
+            this.#events.dispatch(
+                API_MODEL_EVENTS.requestStarted,
+                Object.freeze({requestId:operation.operationId,endpoint:visibleEndpoint}),
+                {
+                    operationId:operation.operationId,
+                    publicDetail:Object.freeze({requestId:operation.operationId})
+                }
+            );
+            if(operation.controller.signal.aborted)throw operation.controller.signal.reason;
+            const request={...this.request};
+            delete request.signal;
+            const response=await this.fetchImpl(url,{
+                method:'GET',
+                ...request,
+                headers:{Accept:'application/json',...(request.headers||{})},
+                signal:operation.controller.signal
+            });
+            if(operation.controller.signal.aborted)throw operation.controller.signal.reason;
+            stage='response';
+            if(!response||typeof response!=='object'||typeof response.json!=='function'){
+                throw new TypeError('The API model fetch implementation returned an invalid response.');
+            }
+            stage='response-json';
+            const raw=await response.json();
+            if(operation.controller.signal.aborted)throw operation.controller.signal.reason;
+            stage='response-status';
+            if(!response.ok){
+                const reason=typeof raw?.reason==='string'&&raw.reason.trim()
+                    ?raw.reason
+                    :typeof raw?.error==='string'&&raw.error.trim()
+                        ?raw.error
+                        :`API request failed (${response.status}).`;
+                throw new Error(reason);
+            }
+            stage='response-parse';
+            const value=await this.parser(raw,{
+                context,
+                endpoint:url.href,
+                response:{status:response.status,headers:response.headers}
+            });
+            if(operation.controller.signal.aborted)throw operation.controller.signal.reason;
+            const record=new ApiModelRecord({
+                endpoint:visibleEndpoint,
+                value,
+                metadata:{requestId:operation.operationId,status:response.status}
+            });
+            stage='cache-write';
+            if(this.cache?.set){
+                await this.cache.set(
+                    visibleEndpoint,
+                    record.toJSON(),
+                    Object.freeze({signal:operation.controller.signal})
+                );
+            }
+            if(operation.controller.signal.aborted)throw operation.controller.signal.reason;
+            this.#assertOpen();
+            operation.settled=true;
+            this.#operations.delete(operation);
+            this.latest=record;
+            this.#events.dispatch(
+                API_MODEL_EVENTS.requestSucceeded,
+                Object.freeze({requestId:operation.operationId,record}),
+                {
+                    operationId:operation.operationId,
+                    publicDetail:Object.freeze({requestId:operation.operationId})
+                }
+            );
+            return record;
+        }catch(error){
+            const normalized=operation.terminalError??operationError(error,stage,operation.controller.signal);
+            operation.settled=true;
+            this.#operations.delete(operation);
+            if(started)this.#publishError(operation,normalized);
+            throw normalized;
+        }finally{
+            this.#finishOperation(operation);
+        }
+    }
+
+    async cached(parameters={},optionsValue={}){
+        this.#assertOpen();
+        const options=requestOptions(optionsValue);
+        if(options.operationId!==null){
+            throw apiModelError(
+                new TypeError('cached() does not accept operationId.'),
+                API_MODEL_ERRORS.requestOptionsInvalid,
+                'cached() does not accept operationId.'
+            );
+        }
+        if(options.signal?.aborted){
+            throw apiModelError(options.signal.reason,API_MODEL_ERRORS.requestAborted,'The API model cache read was aborted.');
+        }
+        const url=appendParameters(new URL(this.endpoint),parameters);
+        if(!this.cache?.get)return null;
+        let value;
+        try{
+            value=await this.cache.get(
+                publicEndpoint(url),
+                Object.freeze({signal:options.signal})
+            );
+        }catch(error){
+            if(options.signal?.aborted){
+                throw apiModelError(options.signal.reason??error,API_MODEL_ERRORS.requestAborted,'The API model cache read was aborted.');
+            }
+            throw apiModelError(error,API_MODEL_ERRORS.cacheReadFailed,'The API model cache read failed.');
+        }
+        this.#assertOpen();
+        if(options.signal?.aborted){
+            throw apiModelError(options.signal.reason,API_MODEL_ERRORS.requestAborted,'The API model cache read was aborted.');
+        }
+        return value?new ApiModelRecord(value):null;
+    }
+
+    dispose(){
+        if(this.#disposed)return false;
+        this.#disposed=true;
+        for(const operation of [...this.#operations]){
+            const error=disposedError();
+            operation.terminalError=error;
+            this.#publishError(operation,error);
+            if(!operation.controller.signal.aborted)operation.controller.abort(error);
+            this.#finishOperation(operation);
+        }
+        return this.#events.dispose();
+    }
+
+    destroy(){return this.dispose();}
 }
 
 export {appendParameters,publicEndpoint};