arcane-os 0.3.0 → 0.3.2

package/runtime/arcane/modules/PreferenceStore.js

@@ -2,7 +2,7 @@ import {createArcaneEventSource} from 'arcane-os/event-manager';
 import Preference,{preferenceSchema} from '../entities/Preference.js';
 import {resolveApplicationLocalStorageKey} from './AppDataScope.js';
 
-export const PREFERENCE_STORE_ERROR_CODES=Object.freeze({
+export const PREFERENCE_STORE_ERROR_CODES={
     adapterInvalid:'ARCANE_PREFERENCE_STORE_ADAPTER_INVALID',
     disposed:'ARCANE_PREFERENCE_STORE_DISPOSED',
     eventDetailInvalid:'ARCANE_PREFERENCE_EVENT_DETAIL_INVALID',
@@ -10,13 +10,13 @@ export const PREFERENCE_STORE_ERROR_CODES=Object.freeze({
     operationAborted:'ARCANE_PREFERENCE_STORE_OPERATION_ABORTED',
     operationOptionsInvalid:'ARCANE_PREFERENCE_STORE_OPERATION_OPTIONS_INVALID',
     valuesInvalid:'ARCANE_PREFERENCE_VALUES_INVALID'
-});
+};
 
-export const PREFERENCE_STORE_EVENT_TYPES=Object.freeze({
+export const PREFERENCE_STORE_EVENT_TYPES={
     change:'preference-change',
     load:'preference-load',
     reset:'preference-reset'
-});
+};
 
 function preferenceStoreError(code,reason,message,ErrorType=Error,cause){
     const error=new ErrorType(message);
@@ -89,7 +89,7 @@ function normalizeOperationOptions(value={}){
             TypeError
         );
     }
-    return Object.freeze({signal});
+    return {signal};
 }
 
 function setDataProperty(target,key,value){
@@ -100,21 +100,23 @@ function setDataProperty(target,key,value){
     );
 }
 
-function frozenPreferenceValues(values){
+function completePreferenceValues(values){
     const copy={};
     for(const [key,value] of Object.entries(values)) setDataProperty(copy,key,value);
-    return Object.freeze(copy);
+    return copy;
 }
 
 function validateAdapter(adapter){
     if(!adapter
         ||typeof adapter.get!=='function'
         ||typeof adapter.set!=='function'
-        ||typeof adapter.delete!=='function'){
+        ||typeof adapter.delete!=='function'
+        ||(Reflect.has(adapter,'setMany')&&typeof adapter.setMany!=='function')){
         throw preferenceStoreError(
             PREFERENCE_STORE_ERROR_CODES.adapterInvalid,
             'preference-storage-adapter-invalid',
-            'The preference storage adapter must provide get, set, and delete methods.',
+            'The preference storage adapter must provide get, set, and delete methods; '
+                +'setMany must be a function when provided.',
             TypeError
         );
     }
@@ -142,7 +144,9 @@ function localAdapter(prefix){
 
 function nativeAdapter(){
     const preferences=globalThis.Arcane?.preferences;
-    if(!preferences?.get||!preferences?.set||!preferences?.delete) return null;
+    if(typeof preferences?.get!=='function'
+        ||typeof preferences?.set!=='function'
+        ||typeof preferences?.delete!=='function') return null;
     return preferences;
 }
 
@@ -162,10 +166,12 @@ function preferenceAdapter(){
         }catch(error){
             if(active!==native||!isUnsupportedNativeAdapter(error)) throw error;
             active=local;
+            delete adapter.setMany;
+            if(typeof active[method]!=='function') throw error;
             return active[method](...args);
         }
     }
-    return {
+    const adapter={
         async get(key){
             return call('get',[key]);
         },
@@ -176,6 +182,12 @@ function preferenceAdapter(){
             return call('delete',[key]);
         }
     };
+    if(typeof native.setMany==='function'){
+        adapter.setMany=async function setMany(entries,context){
+            return call('setMany',[entries,context]);
+        };
+    }
+    return adapter;
 }
 
 export default class PreferenceStore extends EventTarget{
@@ -195,7 +207,7 @@ export default class PreferenceStore extends EventTarget{
             this,
             {
                 source:'preference-store',
-                eventTypes:Object.freeze(Object.values(PREFERENCE_STORE_EVENT_TYPES))
+                eventTypes:Object.values(PREFERENCE_STORE_EVENT_TYPES)
             }
         );
     }
@@ -210,7 +222,7 @@ export default class PreferenceStore extends EventTarget{
         for(const definition of this.schema){
             setDataProperty(values,definition.key,definition.defaultValue);
         }
-        return frozenPreferenceValues(values);
+        return completePreferenceValues(values);
     }
 
     storageKey(key){return `${this.namespace}.${key}`;}
@@ -240,7 +252,7 @@ export default class PreferenceStore extends EventTarget{
                 for(const definition of store.schema){
                     const result=await store.adapter.get(
                         store.storageKey(definition.key),
-                        Object.freeze({operationId,signal:operation.signal})
+                        {operationId,signal:operation.signal}
                     );
                     store.#assertOperationActive(operation.signal);
                     setDataProperty(
@@ -251,9 +263,9 @@ export default class PreferenceStore extends EventTarget{
                             :definition.defaultValue
                     );
                 }
-                store.values=frozenPreferenceValues(values);
+                store.values=completePreferenceValues(values);
                 store.#publish(PREFERENCE_STORE_EVENT_TYPES.load,{},operationId);
-                return frozenPreferenceValues(store.values);
+                return completePreferenceValues(store.values);
             },
             operation.signal
         );
@@ -270,10 +282,10 @@ export default class PreferenceStore extends EventTarget{
                 await store.adapter.set(
                     store.storageKey(key),
                     normalized,
-                    Object.freeze({operationId,signal:operation.signal})
+                    {operationId,signal:operation.signal}
                 );
                 store.#assertOperationActive(operation.signal);
-                store.values=frozenPreferenceValues({...store.values,[key]:normalized});
+                store.values=completePreferenceValues({...store.values,[key]:normalized});
                 store.#publish(
                     PREFERENCE_STORE_EVENT_TYPES.change,
                     {key,value:normalized},
@@ -295,13 +307,64 @@ export default class PreferenceStore extends EventTarget{
                 TypeError
             );
         }
+        const selected=[];
         for(const definition of this.schema){
             if(Object.prototype.hasOwnProperty.call(values,definition.key)){
-                await this.set(definition.key,values[definition.key],operation);
+                selected.push({
+                    key:definition.key,
+                    storageKey:this.storageKey(definition.key),
+                    value:definition.value(values[definition.key])
+                });
             }
         }
-        this.#assertOperationActive(operation.signal);
-        return frozenPreferenceValues(this.values);
+        if(selected.length===0){
+            this.#assertOperationActive(operation.signal);
+            return completePreferenceValues(this.values);
+        }
+        const operationId=this.#nextOperationId('set-all');
+        const store=this;
+        const entries=selected;
+        return this.#enqueueOperation(
+            async function setAllPreferences(commitPreferenceOperation){
+                const context={operationId,signal:operation.signal};
+                if(typeof store.adapter.setMany==='function'){
+                    const batch={};
+                    for(const entry of entries){
+                        setDataProperty(batch,entry.storageKey,entry.value);
+                    }
+                    await store.adapter.setMany(batch,context);
+                    store.#assertOperationActive(operation.signal);
+                    commitPreferenceOperation();
+                    const next={...store.values};
+                    for(const entry of entries) setDataProperty(next,entry.key,entry.value);
+                    store.values=completePreferenceValues(next);
+                    for(const entry of entries){
+                        store.#publish(
+                            PREFERENCE_STORE_EVENT_TYPES.change,
+                            {key:entry.key,value:entry.value},
+                            operationId
+                        );
+                    }
+                    return completePreferenceValues(store.values);
+                }
+                for(const entry of entries){
+                    await store.adapter.set(entry.storageKey,entry.value,context);
+                    store.#assertOperationActive(operation.signal);
+                    store.values=completePreferenceValues({
+                        ...store.values,
+                        [entry.key]:entry.value
+                    });
+                    store.#publish(
+                        PREFERENCE_STORE_EVENT_TYPES.change,
+                        {key:entry.key,value:entry.value},
+                        operationId
+                    );
+                    store.#assertOperationActive(operation.signal);
+                }
+                return completePreferenceValues(store.values);
+            },
+            operation.signal
+        );
     }
 
     async reset(options={}){
@@ -313,13 +376,13 @@ export default class PreferenceStore extends EventTarget{
                 for(const definition of store.schema){
                     await store.adapter.delete(
                         store.storageKey(definition.key),
-                        Object.freeze({operationId,signal:operation.signal})
+                        {operationId,signal:operation.signal}
                     );
                     store.#assertOperationActive(operation.signal);
                 }
                 store.values=store.defaults();
                 store.#publish(PREFERENCE_STORE_EVENT_TYPES.reset,{},operationId);
-                return frozenPreferenceValues(store.values);
+                return completePreferenceValues(store.values);
             },
             operation.signal
         );
@@ -365,19 +428,19 @@ export default class PreferenceStore extends EventTarget{
     }
 
     #publish(type,detail,operationId){
-        const values=frozenPreferenceValues(this.values);
-        const compatibilityDetail=Object.freeze({
+        const values=completePreferenceValues(this.values);
+        const compatibilityDetail={
             ...detail,
             namespace:this.namespace,
             values
-        });
-        const publicDetail=Object.freeze({
+        };
+        const publicDetail={
             namespace:this.namespace,
             values,
             ...(typeof detail.key==='string'
                 ?{preferenceId:detail.key,value:detail.value}
                 :{})
-        });
+        };
         this.#events.dispatch(
             type,
             compatibilityDetail,
@@ -388,6 +451,7 @@ export default class PreferenceStore extends EventTarget{
     #enqueueOperation(operation,signal){
         this.#assertOperationActive(signal);
         const store=this;
+        let committed=false;
         let abortHandler=null;
         let rejectResult;
         let resolveResult;
@@ -410,6 +474,14 @@ export default class PreferenceStore extends EventTarget{
         function cancelPreferenceOperation(error){
             return settlePreferenceOperation(rejectResult,error);
         }
+        function commitPreferenceOperation(){
+            store.#assertOperationActive(signal);
+            if(settled) return false;
+            committed=true;
+            signal?.removeEventListener('abort',abortHandler);
+            store.#pendingOperations.delete(cancelPreferenceOperation);
+            return true;
+        }
         abortHandler=function abortPreferenceOperation(){
             cancelPreferenceOperation(operationAbortedError(signal.reason));
         };
@@ -421,8 +493,8 @@ export default class PreferenceStore extends EventTarget{
             if(settled) return;
             try{
                 store.#assertOperationActive(signal);
-                const value=await operation();
-                store.#assertOperationActive(signal);
+                const value=await operation(commitPreferenceOperation);
+                if(!committed) store.#assertOperationActive(signal);
                 settlePreferenceOperation(resolveResult,value);
             }catch(error){
                 settlePreferenceOperation(rejectResult,error);

package/runtime/arcane/modules/RiskSignalAnalyzer.js

@@ -1,16 +1,16 @@
-const DEFAULT_LEVELS=Object.freeze([
+const DEFAULT_LEVELS=[
     {minimum:70,id:'critical'},
     {minimum:40,id:'high'},
     {minimum:15,id:'caution'},
     {minimum:0,id:'low'},
-]);
+];
 
-function normalizeText(value,maxLength){
-    return String(value??'').normalize('NFKC').slice(0,maxLength);
+function normalizeText(value){
+    return String(value??'').normalize('NFKC');
 }
 
-export function analyzeRiskSignals(input,{signals=[],levels=DEFAULT_LEVELS,maxLength=20_000}={}){
-    const text=normalizeText(input,maxLength);
+export function analyzeRiskSignals(input,{signals=[],levels=DEFAULT_LEVELS}={}){
+    const text=normalizeText(input);
     const matches=[];
     let score=0;
 
@@ -18,7 +18,7 @@ export function analyzeRiskSignals(input,{signals=[],levels=DEFAULT_LEVELS,maxLe
         if(!signal||typeof signal.id!=='string'||!(signal.pattern instanceof RegExp))continue;
         signal.pattern.lastIndex=0;
         if(!signal.pattern.test(text))continue;
-        const weight=Math.max(0,Math.min(100,Number(signal.weight)||0));
+        const weight=Math.max(0,Number(signal.weight)||0);
         score+=weight;
         matches.push({
             id:signal.id,
@@ -28,10 +28,9 @@ export function analyzeRiskSignals(input,{signals=[],levels=DEFAULT_LEVELS,maxLe
         });
     }
 
-    score=Math.min(100,score);
     const ordered=[...levels].sort((a,b)=>b.minimum-a.minimum);
     const level=ordered.find(candidate=>score>=candidate.minimum)?.id||'unknown';
-    return Object.freeze({level,matches:Object.freeze(matches),score,textLength:text.length,truncated:String(input??'').length>text.length});
+    return {level,matches,score,textLength:text.length};
 }
 
 export {DEFAULT_LEVELS};

package/runtime/arcane/modules/ScopedOPFSCache.js

@@ -3,17 +3,13 @@ import {
     openApplicationDataDirectory
 } from './AppDataScope.js';
 
-const DEFAULT_MAX_ENTRY_BYTES=4*1024*1024;
-const MAX_NAMESPACE_LENGTH=96;
-const MAX_KEY_LENGTH=240;
-
-function safeSegment(value,label,maximum){
+function safeSegment(value,label){
     if(typeof value!=='string'){
         throw new TypeError(`${label} must be a string.`);
     }
     const normalized=value.trim();
-    if(!normalized||normalized.length>maximum){
-        throw new RangeError(`${label} must contain between 1 and ${maximum} characters.`);
+    if(!normalized){
+        throw new RangeError(`${label} must not be empty.`);
     }
     if(normalized==='.'||normalized==='..'||/[\\/\0]/u.test(normalized)){
         throw new TypeError(`${label} must be one filename-safe segment.`);
@@ -21,25 +17,12 @@ function safeSegment(value,label,maximum){
     return normalized;
 }
 
-function positiveInteger(value,label,maximum){
-    if(!Number.isSafeInteger(value)||value<1||value>maximum){
-        throw new RangeError(`${label} must be an integer between 1 and ${maximum}.`);
-    }
-    return value;
-}
-
 function unavailable(){
     const error=new Error('Origin Private File System storage is unavailable in this browser.');
     error.code='OPFS_UNAVAILABLE';
     return error;
 }
 
-function entryTooLarge(maximum){
-    const error=new RangeError(`The cache entry exceeds the ${maximum}-byte limit.`);
-    error.code='OPFS_CACHE_ENTRY_TOO_LARGE';
-    return error;
-}
-
 /**
  * A deliberately narrow JSON cache over one application-owned OPFS directory.
  *
@@ -52,14 +35,12 @@ export default class ScopedOPFSCache{
     #arcane;
     #directoryPromise=null;
     #documentObject;
-    #maxEntryBytes;
     #namespace;
     #storage;
 
     constructor({
         applicationId=null,
         namespace,
-        maxEntryBytes=DEFAULT_MAX_ENTRY_BYTES,
         storage=globalThis.navigator?.storage,
         documentObject=globalThis.document,
         arcane=globalThis.Arcane
@@ -67,8 +48,7 @@ export default class ScopedOPFSCache{
         this.#applicationId=applicationId==null||applicationId===''
             ?null
             :canonicalApplicationId(applicationId);
-        this.#namespace=safeSegment(namespace,'namespace',MAX_NAMESPACE_LENGTH);
-        this.#maxEntryBytes=positiveInteger(maxEntryBytes,'maxEntryBytes',64*1024*1024);
+        this.#namespace=safeSegment(namespace,'namespace');
         if(!storage||typeof storage.getDirectory!=='function'){
             throw unavailable();
         }
@@ -89,10 +69,6 @@ export default class ScopedOPFSCache{
         return this.#applicationId;
     }
 
-    get maxEntryBytes(){
-        return this.#maxEntryBytes;
-    }
-
     async #directory(){
         if(!this.#directoryPromise){
             this.#directoryPromise=(async()=>{
@@ -117,20 +93,12 @@ export default class ScopedOPFSCache{
     }
 
     async get(key){
-        const normalized=safeSegment(key,'key',MAX_KEY_LENGTH);
+        const normalized=safeSegment(key,'key');
         try{
             const directory=await this.#directory();
             const handle=await directory.getFileHandle(normalized);
             const file=await handle.getFile();
-            if(file.size>this.#maxEntryBytes){
-                await this.delete(normalized).catch(()=>{});
-                return undefined;
-            }
             const source=await file.text();
-            if(new TextEncoder().encode(source).byteLength>this.#maxEntryBytes){
-                await this.delete(normalized).catch(()=>{});
-                return undefined;
-            }
             try{
                 return JSON.parse(source);
             }catch{
@@ -146,14 +114,11 @@ export default class ScopedOPFSCache{
     }
 
     async set(key,value){
-        const normalized=safeSegment(key,'key',MAX_KEY_LENGTH);
+        const normalized=safeSegment(key,'key');
         const source=JSON.stringify(value);
         if(source===undefined){
             throw new TypeError('Cache values must be JSON serializable.');
         }
-        if(new TextEncoder().encode(source).byteLength>this.#maxEntryBytes){
-            throw entryTooLarge(this.#maxEntryBytes);
-        }
         const directory=await this.#directory();
         const handle=await directory.getFileHandle(normalized,{create:true});
         const writable=await handle.createWritable();
@@ -168,7 +133,7 @@ export default class ScopedOPFSCache{
     }
 
     async delete(key){
-        const normalized=safeSegment(key,'key',MAX_KEY_LENGTH);
+        const normalized=safeSegment(key,'key');
         const directory=await this.#directory();
         try{
             await directory.removeEntry(normalized);