arcane-os 0.3.1 → 0.3.2

package/runtime/arcane/modules/MailTransport.mjs

@@ -1,24 +1,24 @@
-export const DEFAULT_MAIL_REQUEST_TIMEOUT_MS=590_000;
-export const MAX_MAIL_RESPONSE_BYTES=65_536;
+export const DEFAULT_MAIL_REQUEST_TIMEOUT_MS=null;
 
-const REPORT_KEY_PATTERN=/^[a-zA-Z0-9._:-]{8,128}$/;
-const REQUEST_ID_PATTERN=/^[a-zA-Z0-9-]{8,128}$/;
-const PROVIDER_ID_PATTERN=/^[a-zA-Z0-9._:-]{1,256}$/;
-const ERROR_CODE_PATTERN=/^[a-zA-Z0-9._:-]{1,80}$/;
+const REPORT_KEY_PATTERN=/^[a-zA-Z0-9._:-]+$/;
+const REQUEST_ID_PATTERN=/^[a-zA-Z0-9-]+$/;
+const PROVIDER_ID_PATTERN=/^[a-zA-Z0-9._:-]+$/;
+const ERROR_CODE_PATTERN=/^[a-zA-Z0-9._:-]+$/;
 const RETRYABLE_STATUS_CODES=new Set([408,425,429,500,502,503,504]);
 const NON_RETRYABLE_RATE_CODES=new Set(['daily_quota_exceeded','monthly_quota_exceeded']);
-const RESPONSE_CONTRACT=Object.freeze({
+const RESPONSE_CONTRACT={
     accepted:202,
     delivery_uncertain:207,
     partially_accepted:207,
-});
+};
 
 export class MailTransportError extends Error {
-    constructor(message,{cause,code='MAIL_TRANSPORT_ERROR',retryable=false,
+    constructor(message,{cause,code='MAIL_TRANSPORT_ERROR',details=null,retryable=false,
         retryAfterMs=0,statusCode=0,uncertain=false}={}){
         super(message,{cause});
         this.name='MailTransportError';
         this.code=code;
+        this.details=details;
         this.retryable=Boolean(retryable);
         this.retryAfterMs=Number.isSafeInteger(retryAfterMs)&&retryAfterMs>0
             ? retryAfterMs
@@ -94,17 +94,18 @@ function parseRetryAfter(value,now=Date.now()){
     }
     const trimmed=value.trim();
     if(/^\d+(?:\.\d+)?$/u.test(trimmed)){
-        return Math.min(86_400_000,Math.max(0,Math.ceil(Number(trimmed)*1000)));
+        return Math.max(0,Math.ceil(Number(trimmed)*1000));
     }
     const timestamp=Date.parse(trimmed);
     return Number.isFinite(timestamp)
-        ? Math.min(86_400_000,Math.max(0,timestamp-now))
+        ? Math.max(0,timestamp-now)
         : 0;
 }
 
-function invalidSuccessResponse(response){
+function invalidSuccessResponse(response,responseText){
     return new MailTransportError('Mail server returned an invalid success response',{
         code:'MAIL_INVALID_RESPONSE',statusCode:response.status,uncertain:true,
+        details:parseJsonObject(responseText)??responseText
     });
 }
 
@@ -114,20 +115,21 @@ function parseDeliveryResponse(response,responseText){
         || typeof body.requestId!=='string'||!REQUEST_ID_PATTERN.test(body.requestId)
         || !Object.hasOwn(RESPONSE_CONTRACT,body.status)
         || RESPONSE_CONTRACT[body.status]!==response.status) {
-        throw invalidSuccessResponse(response);
+        throw invalidSuccessResponse(response,responseText);
     }
     for(const field of ['accepted','rejected']){
         if(body[field]!==undefined
             && (!Number.isSafeInteger(body[field])||body[field]<0)) {
-            throw invalidSuccessResponse(response);
+            throw invalidSuccessResponse(response,responseText);
         }
     }
     if(body.providerId!==undefined
         && (typeof body.providerId!=='string'||!PROVIDER_ID_PATTERN.test(body.providerId))){
-        throw invalidSuccessResponse(response);
+        throw invalidSuccessResponse(response,responseText);
     }
 
     return {
+        ...body,
         requestId:body.requestId,
         sent:body.status==='accepted',
         partial:body.status==='partially_accepted',
@@ -164,6 +166,7 @@ function parseRejection(response,responseText){
         : 0;
     return new MailTransportError(`Mail server rejected the request (${response.status})`,{
         code,
+        details:body??responseText,
         retryable,
         retryAfterMs:bodyRetryAfter||parseRetryAfter(response.headers?.get?.('retry-after')),
         statusCode:response.status,
@@ -171,37 +174,18 @@ function parseRejection(response,responseText){
     });
 }
 
-async function readBoundedResponseText(response){
-    const declaredLength=response.headers?.get?.('content-length');
-    if(declaredLength!==null&&declaredLength!==undefined&&declaredLength!==''){
-        const parsedLength=Number(declaredLength);
-        if(!Number.isSafeInteger(parsedLength)||parsedLength<0||parsedLength>MAX_MAIL_RESPONSE_BYTES){
-            throw new MailTransportError(
-                `Mail server response cannot exceed ${MAX_MAIL_RESPONSE_BYTES.toLocaleString('en-US')} bytes`,
-                {code:'MAIL_RESPONSE_TOO_LARGE',statusCode:response.status,uncertain:true}
-            );
-        }
-    }
-
+async function readResponseText(response){
     if(!response.body||typeof response.body.getReader!=='function'){
         if(typeof response.text!=='function'){
             throw new MailTransportError('Mail server returned an unreadable response',{
                 code:'MAIL_UNREADABLE_RESPONSE',statusCode:response.status,uncertain:true,
             });
         }
-        const text=await response.text();
-        if(new TextEncoder().encode(text).byteLength>MAX_MAIL_RESPONSE_BYTES){
-            throw new MailTransportError(
-                `Mail server response cannot exceed ${MAX_MAIL_RESPONSE_BYTES.toLocaleString('en-US')} bytes`,
-                {code:'MAIL_RESPONSE_TOO_LARGE',statusCode:response.status,uncertain:true}
-            );
-        }
-        return text;
+        return response.text();
     }
 
     const reader=response.body.getReader();
     const decoder=new TextDecoder();
-    let byteLength=0;
     let text='';
     try{
         while(true){
@@ -212,14 +196,6 @@ async function readBoundedResponseText(response){
                     code:'MAIL_UNREADABLE_RESPONSE',statusCode:response.status,uncertain:true,
                 });
             }
-            byteLength+=value.byteLength;
-            if(byteLength>MAX_MAIL_RESPONSE_BYTES){
-                await reader.cancel().catch(function ignoreReaderCancellation(){});
-                throw new MailTransportError(
-                    `Mail server response cannot exceed ${MAX_MAIL_RESPONSE_BYTES.toLocaleString('en-US')} bytes`,
-                    {code:'MAIL_RESPONSE_TOO_LARGE',statusCode:response.status,uncertain:true}
-                );
-            }
             text+=decoder.decode(value,{stream:true});
         }
         text+=decoder.decode();
@@ -235,7 +211,7 @@ function requestBodyFrom({report,serializedReport}){
     }
     const validated=validateSerializedReport(serializedReport);
     if(report!==undefined&&serializeMailReport(report)!==validated){
-        throw new Error('Mail report does not match its immutable serialized request body');
+        throw new Error('Mail report does not match its stored serialized request body');
     }
     return validated;
 }
@@ -259,10 +235,11 @@ export async function sendMailReport({
         throw new Error('Mail application identity is invalid');
     }
     if(typeof reportKey!=='string'||!REPORT_KEY_PATTERN.test(reportKey)){
-        throw new Error('Mail report key must contain 8-128 safe characters');
+        throw new Error('Mail report key must contain safe characters');
     }
-    if(!Number.isSafeInteger(requestTimeout)||requestTimeout<1_000||requestTimeout>600_000){
-        throw new Error('Mail request timeout must be an integer between 1000 and 600000 milliseconds');
+    if(requestTimeout!==null&&requestTimeout!==undefined
+        &&(!Number.isSafeInteger(requestTimeout)||requestTimeout<1)){
+        throw new Error('Mail request timeout must be a positive integer');
     }
     if(appKey!==undefined&&appKey!==null&&typeof appKey!=='string'){
         throw new Error('Mail application key must be a string');
@@ -290,13 +267,15 @@ export async function sendMailReport({
     if(signal?.aborted){
         forwardAbort();
     }
-    const timeout=setTimeout(
-        function abortTimedOutMail(){
-            timedOut=true;
-            controller.abort(new Error('Mail request timed out'));
-        },
-        requestTimeout
-    );
+    const timeout=requestTimeout==null
+        ?null
+        :setTimeout(
+            function abortTimedOutMail(){
+                timedOut=true;
+                controller.abort(new Error('Mail request timed out'));
+            },
+            requestTimeout
+        );
 
     try{
         let response;
@@ -326,13 +305,13 @@ export async function sendMailReport({
             );
         }
 
-        const responseText=await readBoundedResponseText(response);
+        const responseText=await readResponseText(response);
         if(!response.ok){
             throw parseRejection(response,responseText);
         }
         return parseDeliveryResponse(response,responseText);
     }finally{
-        clearTimeout(timeout);
+        if(timeout!==null) clearTimeout(timeout);
         signal?.removeEventListener('abort',forwardAbort);
     }
 }

package/runtime/arcane/modules/ModelDefinition.js

@@ -1,9 +1,5 @@
-const MAX_MODEL_DEFINITION_CHARACTERS=128*1024;
-const MAX_SYSTEM_PROMPT_CHARACTERS=96*1024;
-const MAX_PARAMETER_COUNT=32;
-const MAX_RESPONSE_BYTES=MAX_MODEL_DEFINITION_CHARACTERS*4;
-const MODEL_REFERENCE=/^[A-Za-z0-9][A-Za-z0-9._/-]{0,191}(?::[A-Za-z0-9][A-Za-z0-9._-]{0,63})?$/;
-const PARAMETER_NAME=/^[a-z][a-z0-9_]{0,63}$/;
+const MODEL_REFERENCE=/^[A-Za-z0-9][A-Za-z0-9._/-]*(?::[A-Za-z0-9][A-Za-z0-9._-]*)?$/;
+const PARAMETER_NAME=/^[a-z][a-z0-9_]*$/;
 
 function fail(message){
     const error=new TypeError(message);
@@ -11,83 +7,18 @@ function fail(message){
     throw error;
 }
 
-function freeze(value){
-    if(!value||typeof value!=='object'||Object.isFrozen(value)){
-        return value;
+async function completeResponseText(response){
+    if(typeof response?.text!=='function'){
+        fail('The model definition response is not readable.');
     }
 
-    for(const child of Object.values(value)){
-        freeze(child);
-    }
-
-    return Object.freeze(value);
-}
-
-function responseLength(response){
-    const raw=response?.headers?.get?.('content-length');
+    const text=await response.text();
 
-    if(raw===null||raw===undefined||raw===''){
-        return null;
+    if(typeof text!=='string'){
+        fail('The model definition response is not readable text.');
     }
 
-    const value=Number(raw);
-    return Number.isSafeInteger(value)&&value>=0?value:Number.POSITIVE_INFINITY;
-}
-
-async function boundedResponseText(response,maxBytes=MAX_RESPONSE_BYTES){
-    const declaredLength=responseLength(response);
-
-    if(declaredLength!==null&&declaredLength>maxBytes){
-        fail('The model definition response exceeds the allowed size.');
-    }
-
-    const reader=response?.body?.getReader?.();
-
-    if(!reader){
-        if(typeof response?.text!=='function'){
-            fail('The model definition response is not readable.');
-        }
-
-        const text=await response.text();
-
-        if(typeof text!=='string'||new TextEncoder().encode(text).byteLength>maxBytes){
-            fail('The model definition response exceeds the allowed size.');
-        }
-
-        return text;
-    }
-
-    const decoder=new TextDecoder('utf-8',{fatal:true});
-    const parts=[];
-    let total=0;
-
-    try{
-        while(true){
-            const {done,value}=await reader.read();
-
-            if(done){
-                break;
-            }
-            if(!(value instanceof Uint8Array)){
-                fail('The model definition response contained an invalid byte chunk.');
-            }
-
-            total+=value.byteLength;
-            if(total>maxBytes){
-                await reader.cancel?.();
-                fail('The model definition response exceeds the allowed size.');
-            }
-            parts.push(decoder.decode(value,{stream:true}));
-        }
-        parts.push(decoder.decode());
-    }catch(error){
-        if(error?.code==='MODEL_DEFINITION_INVALID'){
-            throw error;
-        }
-        fail('The model definition response is not valid UTF-8 text.');
-    }
-
-    return parts.join('');
+    return text;
 }
 
 /**
@@ -98,17 +29,15 @@ async function boundedResponseText(response,maxBytes=MAX_RESPONSE_BYTES){
 export function parseModelDefinition(source){
     if(typeof source!=='string'
         ||!source
-        ||source.length>MAX_MODEL_DEFINITION_CHARACTERS
         ||source.includes('\0')
     ){
-        fail('The model definition must be bounded non-empty text.');
+        fail('The model definition must be non-empty text without null characters.');
     }
 
-    const normalized=source.replaceAll('\r\n','\n');
-
-    if(normalized.includes('\r')||normalized.startsWith('\uFEFF')){
-        fail('The model definition must use canonical UTF-8 line endings.');
-    }
+    const normalized=source
+        .replace(/^\uFEFF/u,'')
+        .replaceAll('\r\n','\n')
+        .replaceAll('\r','\n');
 
     const match=normalized.match(
         /^FROM ([^\n]+)\n\nSYSTEM """\n([\s\S]*?)\n"""(?:\n\n([\s\S]+?))?\n?$/
@@ -125,18 +54,9 @@ export function parseModelDefinition(source){
     if(!MODEL_REFERENCE.test(from)){
         fail('The model definition contains an invalid base-model reference.');
     }
-    if(!system.trim()
-        ||system!==system.trim()
-        ||system.length>MAX_SYSTEM_PROMPT_CHARACTERS
-        ||system.split('\n').some(function systemLineTooLong(line){
-            return line.length>4096;
-        })
-    ){
+    if(!system.trim()){
         fail('The model definition contains an invalid SYSTEM prompt.');
     }
-    if(parameterLines.length>MAX_PARAMETER_COUNT){
-        fail('The model definition contains an invalid parameter count.');
-    }
 
     const parameters={};
 
@@ -145,8 +65,7 @@ export function parseModelDefinition(source){
 
         if(!parameter
             ||!PARAMETER_NAME.test(parameter[1])
-            ||parameter[2]!==parameter[2].trim()
-            ||parameter[2].length>256
+            ||!parameter[2].trim()
             ||Object.hasOwn(parameters,parameter[1])
         ){
             fail(`The model definition contains an invalid parameter line: ${line}`);
@@ -155,13 +74,13 @@ export function parseModelDefinition(source){
         parameters[parameter[1]]=parameter[2];
     }
 
-    return freeze({from,system,parameters});
+    return {from,system,parameters};
 }
 
 /**
- * Loads a packaged definition with a read-only same-origin GET and returns the
- * SYSTEM block. The definition is never evaluated and no model service is
- * contacted by this helper.
+ * Loads a packaged definition with an ordinary read-only GET and returns the
+ * complete SYSTEM block. The definition is never evaluated and no model
+ * service is contacted by this helper.
  */
 export async function loadModelDefinitionSystemPrompt(url,{
     fetchImpl=globalThis.fetch
@@ -171,10 +90,7 @@ export async function loadModelDefinitionSystemPrompt(url,{
     }
 
     const response=await fetchImpl(url,{
-        method:'GET',
-        credentials:'same-origin',
-        cache:'default',
-        redirect:'error'
+        method:'GET'
     });
 
     if(!response||response.ok!==true){
@@ -185,5 +101,5 @@ export async function loadModelDefinitionSystemPrompt(url,{
         throw error;
     }
 
-    return parseModelDefinition(await boundedResponseText(response)).system;
+    return parseModelDefinition(await completeResponseText(response)).system;
 }

package/runtime/arcane/modules/OpenMeteoWeatherProvider.js

@@ -2,40 +2,40 @@ import {createArcaneEventSource} from 'arcane-os/event-manager';
 import ApiModelDatabase from './ApiModelDatabase.js';
 import {WeatherDay,WeatherLocation,WeatherObservation,WeatherSnapshot} from '../entities/Weather.js';
 
-export const OPEN_METEO_ENDPOINTS=Object.freeze({
+export const OPEN_METEO_ENDPOINTS={
     geocoding:'https://geocoding-api.open-meteo.com/v1/search',
     forecast:'https://api.open-meteo.com/v1/forecast'
-});
+};
 
-export const OPEN_METEO_WEATHER_EVENTS=Object.freeze({
+export const OPEN_METEO_WEATHER_EVENTS={
     requestStarted:'weather-request',
     requestFailed:'weather-error',
     locationSearchSucceeded:'weather-locations',
     forecastLoadSucceeded:'weather-weather'
-});
-
-const WEATHER_EVENT_TYPES=Object.freeze(Object.values(OPEN_METEO_WEATHER_EVENTS));
-
-export const OPEN_METEO_WEATHER_ERRORS=Object.freeze({
-    providerDisposed:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_PROVIDER_DISPOSED',reason:'open-meteo-weather-provider-disposed'}),
-    weatherEventTypeInvalid:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_EVENT_TYPE_INVALID',reason:'weather-event-type-invalid'}),
-    weatherLocationInvalid:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_INVALID',reason:'weather-location-invalid'}),
-    weatherOperationOptionsInvalid:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_OPERATION_OPTIONS_INVALID',reason:'weather-operation-options-invalid'}),
-    weatherLocationQueryInvalid:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_QUERY_INVALID',reason:'weather-location-query-invalid'}),
-    locationSearchAborted:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_SEARCH_ABORTED',reason:'weather-location-search-aborted'}),
-    locationSearchFailed:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_SEARCH_FAILED',reason:'weather-location-search-rejected'}),
-    locationSearchSuperseded:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_SEARCH_SUPERSEDED',reason:'weather-location-search-superseded'}),
-    forecastLoadAborted:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_FORECAST_LOAD_ABORTED',reason:'weather-forecast-load-aborted'}),
-    forecastLoadFailed:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_FORECAST_LOAD_FAILED',reason:'weather-forecast-load-rejected'}),
-    forecastLoadSuperseded:Object.freeze({code:'ARCANE_OPEN_METEO_WEATHER_FORECAST_LOAD_SUPERSEDED',reason:'weather-forecast-load-superseded'})
-});
-
-const WEATHER_EVENT_NAMES=Object.freeze({
+};
+
+const WEATHER_EVENT_TYPES=Object.values(OPEN_METEO_WEATHER_EVENTS);
+
+export const OPEN_METEO_WEATHER_ERRORS={
+    providerDisposed:{code:'ARCANE_OPEN_METEO_WEATHER_PROVIDER_DISPOSED',reason:'open-meteo-weather-provider-disposed'},
+    weatherEventTypeInvalid:{code:'ARCANE_OPEN_METEO_WEATHER_EVENT_TYPE_INVALID',reason:'weather-event-type-invalid'},
+    weatherLocationInvalid:{code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_INVALID',reason:'weather-location-invalid'},
+    weatherOperationOptionsInvalid:{code:'ARCANE_OPEN_METEO_WEATHER_OPERATION_OPTIONS_INVALID',reason:'weather-operation-options-invalid'},
+    weatherLocationQueryInvalid:{code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_QUERY_INVALID',reason:'weather-location-query-invalid'},
+    locationSearchAborted:{code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_SEARCH_ABORTED',reason:'weather-location-search-aborted'},
+    locationSearchFailed:{code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_SEARCH_FAILED',reason:'weather-location-search-rejected'},
+    locationSearchSuperseded:{code:'ARCANE_OPEN_METEO_WEATHER_LOCATION_SEARCH_SUPERSEDED',reason:'weather-location-search-superseded'},
+    forecastLoadAborted:{code:'ARCANE_OPEN_METEO_WEATHER_FORECAST_LOAD_ABORTED',reason:'weather-forecast-load-aborted'},
+    forecastLoadFailed:{code:'ARCANE_OPEN_METEO_WEATHER_FORECAST_LOAD_FAILED',reason:'weather-forecast-load-rejected'},
+    forecastLoadSuperseded:{code:'ARCANE_OPEN_METEO_WEATHER_FORECAST_LOAD_SUPERSEDED',reason:'weather-forecast-load-superseded'}
+};
+
+const WEATHER_EVENT_NAMES={
     error:OPEN_METEO_WEATHER_EVENTS.requestFailed,
     locations:OPEN_METEO_WEATHER_EVENTS.locationSearchSucceeded,
     request:OPEN_METEO_WEATHER_EVENTS.requestStarted,
     weather:OPEN_METEO_WEATHER_EVENTS.forecastLoadSucceeded
-});
+};
 
 function signalLike(value){
     return value===undefined
@@ -110,7 +110,7 @@ function normalizedOperationError(error,record){
 }
 
 function operationOptions(value){
-    if(value===undefined)return Object.freeze({signal:null});
+    if(value===undefined)return {signal:null};
     if(!value||typeof value!=='object'||Array.isArray(value)){
         throw invalidOptionsError('Open-Meteo operation options must be an object.');
     }
@@ -152,14 +152,10 @@ function parseLocations(raw){
 function parseForecast(raw,{context}){return mapForecast(raw,context.location);}
 
 export default class OpenMeteoWeatherProvider extends EventTarget{
-    #activeLoad=null;
-    #activeSearch=null;
     #disposed=false;
     #events;
-    #loadGeneration=0;
     #operationSequence=0;
     #operations=new Map();
-    #searchGeneration=0;
     #unsubscribe=[];
 
     constructor({
@@ -210,12 +206,6 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
         }
     }
 
-    #currentOperation(record){
-        return record.kind==='location-search'
-            ?this.#activeSearch===record&&this.#searchGeneration===record.generation
-            :this.#activeLoad===record&&this.#loadGeneration===record.generation;
-    }
-
     #releaseSignal(record){
         if(!Array.isArray(record.cleanup))return;
         for(const remove of record.cleanup.splice(0))remove();
@@ -225,8 +215,6 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
         if(record.settled)return;
         record.settled=true;
         this.#releaseSignal(record);
-        if(record.kind==='location-search'&&this.#activeSearch===record)this.#activeSearch=null;
-        if(record.kind==='forecast-load'&&this.#activeLoad===record)this.#activeLoad=null;
     }
 
     #finishOperation(record){
@@ -243,30 +231,8 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
                 'The weather event type is invalid.'
             );
         }
-        const compatibilityDetail=Object.freeze({...detail,operationId});
-        const operation=typeof detail?.operation==='string'?detail.operation:null;
-        let publicDetail;
-        if(type==='request'){
-            publicDetail=Object.freeze(operation?{operation}:{});
-        }else if(type==='error'){
-            publicDetail=Object.freeze({
-                ...(operation?{operation}:{}),
-                ...(typeof detail?.error?.code==='string'?{code:detail.error.code}:{}),
-                ...(typeof detail?.error?.reason==='string'?{reason:detail.error.reason}:{})
-            });
-        }else if(type==='locations'){
-            publicDetail=Object.freeze({
-                ...(operation?{operation}:{}),
-                count:Array.isArray(detail?.locations)?detail.locations.length:0
-            });
-        }else{
-            publicDetail=Object.freeze({
-                ...(operation?{operation}:{}),
-                ...(typeof detail?.weather?.location?.id==='string'
-                    ?{locationId:detail.weather.location.id}
-                    :{})
-            });
-        }
+        const compatibilityDetail={...detail,operationId};
+        const publicDetail={...compatibilityDetail};
         return this.#events.dispatch(eventType,compatibilityDetail,{operationId,publicDetail});
     }
 
@@ -309,16 +275,12 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
                 operationMessage(kind,'aborted')
             );
         }
-        const generation=kind==='location-search'
-            ?++this.#searchGeneration
-            :++this.#loadGeneration;
         const operationId=`${this.#events.instanceId}:${kind}:${(++this.#operationSequence).toString(36)}`;
         const controller=new AbortController();
         const record={
             cleanup:[],
             controller,
             errorPublished:false,
-            generation,
             kind,
             operationId,
             publicError:null,
@@ -326,20 +288,7 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
             terminalError:null
         };
         linkAbortSignal(signal??null,controller,record.cleanup);
-        const previous=kind==='location-search'?this.#activeSearch:this.#activeLoad;
-        if(kind==='location-search')this.#activeSearch=record;
-        else this.#activeLoad=record;
         this.#operations.set(operationId,record);
-        if(previous){
-            this.#terminateOperation(
-                previous,
-                defineWeatherError(
-                    new Error(operationMessage(kind,'superseded')),
-                    operationContract(kind,'superseded'),
-                    operationMessage(kind,'superseded')
-                )
-            );
-        }
         return record;
     }
 
@@ -348,7 +297,6 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
         const operationId=event?.operationId??event?.detail?.requestId;
         if(typeof operationId!=='string'||!operationId)return;
         const record=this.#operations.get(operationId);
-        if(record&&!this.#currentOperation(record))return;
         this.#dispatch(
             'request',
             {...(event.detail||{}),operation:record?.kind??kind},
@@ -383,37 +331,30 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
         this.#assertOpen();
         if(geocoding)this.geocoder.setEndpoint(geocoding);
         if(forecast)this.forecast.setEndpoint(forecast);
-        return Object.freeze({
+        return {
             geocoding:this.geocoder.endpoint,
             forecast:this.forecast.endpoint
-        });
+        };
     }
 
     async search(query,optionsValue={}){
         this.#assertOpen();
-        const name=String(query||'').trim();
-        if(name.length<2){
+        const name=String(query??'');
+        if(!name.trim()){
             throw defineWeatherError(
-                new TypeError('Enter at least two characters for a location search.'),
+                new TypeError('Enter a location to search.'),
                 OPEN_METEO_WEATHER_ERRORS.weatherLocationQueryInvalid,
-                'Enter at least two characters for a location search.'
+                'Enter a location to search.'
             );
         }
         const options=operationOptions(optionsValue);
         const record=this.#startOperation('location-search',options.signal??null);
         try{
             const result=await this.geocoder.fetch(
-                {name,count:8,language:'en',format:'json'},
+                {name,language:'en',format:'json'},
                 {},
                 {signal:record.controller.signal,operationId:record.operationId}
             );
-            if(!this.#currentOperation(record)){
-                throw record.terminalError??defineWeatherError(
-                    new Error(operationMessage(record.kind,'superseded')),
-                    operationContract(record.kind,'superseded'),
-                    operationMessage(record.kind,'superseded')
-                );
-            }
             this.#finishOperation(record);
             this.#dispatch(
                 'locations',
@@ -450,8 +391,12 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
         const {
             temperatureUnit='fahrenheit',
             windSpeedUnit='mph',
-            precipitationUnit='inch'
+            precipitationUnit='inch',
+            forecastDays
         }=options;
+        if(forecastDays!==undefined&&(!Number.isSafeInteger(forecastDays)||forecastDays<=0)){
+            throw invalidOptionsError('Open-Meteo forecastDays must be a positive integer when provided.');
+        }
         const record=this.#startOperation('forecast-load',options.signal??null);
         try{
             const result=await this.forecast.fetch(
@@ -459,7 +404,7 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
                     latitude:place.latitude,
                     longitude:place.longitude,
                     timezone:'auto',
-                    forecast_days:7,
+                    ...(forecastDays===undefined?{}:{forecast_days:forecastDays}),
                     temperature_unit:temperatureUnit,
                     wind_speed_unit:windSpeedUnit,
                     precipitation_unit:precipitationUnit,
@@ -484,13 +429,6 @@ export default class OpenMeteoWeatherProvider extends EventTarget{
                 {location:place},
                 {signal:record.controller.signal,operationId:record.operationId}
             );
-            if(!this.#currentOperation(record)){
-                throw record.terminalError??defineWeatherError(
-                    new Error(operationMessage(record.kind,'superseded')),
-                    operationContract(record.kind,'superseded'),
-                    operationMessage(record.kind,'superseded')
-                );
-            }
             this.#finishOperation(record);
             this.#dispatch(
                 'weather',