arcane-os 0.1.0-dev.5

package/runtime/arcane/modules/DBOPFSWorker.js

@@ -0,0 +1,116 @@
+self.addEventListener(
+    'message',
+    async function accessFile(event){
+        const port=event.ports[0];
+        const operation=event.data.operation||'write';
+        let response={success:true};
+        let accessHandle;
+
+        try{
+            try{
+                const root=await navigator.storage.getDirectory();
+                const applicationId=String(event.data.applicationId||'');
+
+                if(applicationId.length>64
+                    ||!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(applicationId)){
+                    throw new DOMException(
+                        'Arcane rejected an invalid application data scope.',
+                        'SecurityError'
+                    );
+                }
+
+                const applications=await root.getDirectoryHandle(
+                    'apps',
+                    {create:operation==='write'}
+                );
+                const application=await applications.getDirectoryHandle(
+                    applicationId,
+                    {create:operation==='write'}
+                );
+                const directory=await application.getDirectoryHandle(
+                    event.data.directoryName,
+                    {create:operation==='write'}
+                );
+                const file=await directory.getFileHandle(
+                    event.data.fileName,
+                    {create:operation==='write'}
+                );
+
+                if(typeof file.createSyncAccessHandle!=='function'){
+                    throw new DOMException(
+                        'OPFS file access is not supported in this browser.',
+                        'NotSupportedError'
+                    );
+                }
+
+                accessHandle=await file.createSyncAccessHandle();
+
+                if(operation==='read'){
+                    const fileData=new Uint8Array(accessHandle.getSize());
+                    let bytesRead=0;
+
+                    while(bytesRead<fileData.byteLength){
+                        const read=accessHandle.read(
+                            fileData.subarray(bytesRead),
+                            {at:bytesRead}
+                        );
+
+                        if(read<1){
+                            throw new Error('OPFS read did not make progress.');
+                        }
+
+                        bytesRead+=read;
+                    }
+
+                    response={
+                        success:true,
+                        fileData:fileData.buffer
+                    };
+                }else{
+                    const fileData=new Uint8Array(event.data.fileData);
+                    const writePosition=event.data.append ? accessHandle.getSize() : 0;
+
+                    if(!event.data.append){
+                        accessHandle.truncate(0);
+                    }
+
+                    let bytesWritten=0;
+
+                    while(bytesWritten<fileData.byteLength){
+                        const written=accessHandle.write(
+                            fileData.subarray(bytesWritten),
+                            {at:writePosition+bytesWritten}
+                        );
+
+                        if(written<1){
+                            throw new Error('OPFS write did not make progress.');
+                        }
+
+                        bytesWritten+=written;
+                    }
+
+                    accessHandle.flush();
+                }
+            }finally{
+                if(accessHandle){
+                    accessHandle.close();
+                }
+            }
+        }catch(error){
+            response={
+                error:{
+                    name:error.name||'Error',
+                    message:error.message||String(error)
+                }
+            };
+        }
+
+        if(response.fileData){
+            port.postMessage(response,[response.fileData]);
+        }else{
+            port.postMessage(response);
+        }
+
+        port.close();
+    }
+);

package/runtime/arcane/modules/DataMaintenance.js

@@ -0,0 +1,91 @@
+import './DBOPFS.js';
+import {hasUserEntry} from './ChatRecords.js';
+import {hasMemoryContent} from './MemoryRecords.js';
+
+async function clearEmptyChatsAndMemories(){
+    await waitForDBOPFS();
+
+    const chatFileNames=await dbopfs.getAllKeys('chats');
+    const emptyChats=[];
+
+    for(let i=0;i<chatFileNames.length;i++){
+        const chat=await dbopfs.get(
+            'chats',
+            chatFileNames[i],
+            true
+        );
+
+        if(!hasUserEntry(chat)){
+            emptyChats.push(chatFileNames[i]);
+        }
+    }
+
+    const memoryFileNames=await dbopfs.getAllKeys('memories');
+    const associatedMemories=new Set(
+        emptyChats.map(chatFileName=>`memory-${chatFileName}`)
+    );
+    const emptyMemories=new Set();
+
+    for(let i=0;i<memoryFileNames.length;i++){
+        const memory=await dbopfs.get(
+            'memories',
+            memoryFileNames[i],
+            true
+        );
+
+        if(
+            associatedMemories.has(memoryFileNames[i])
+            || !hasMemoryContent(memory)
+        ){
+            emptyMemories.add(memoryFileNames[i]);
+        }
+    }
+
+    const chatResults=await dbopfs.deleteMany('chats',emptyChats);
+    const memoryResults=await dbopfs.deleteMany(
+        'memories',
+        Array.from(emptyMemories)
+    );
+    const deletedChats=chatResults.filter(
+        result=>result.status==='fulfilled'
+    ).length;
+    const deletedMemories=memoryResults.filter(
+        result=>result.status==='fulfilled'
+    ).length;
+
+    return {
+        checkedChats:chatFileNames.length,
+        checkedMemories:memoryFileNames.length,
+        deletedChats:deletedChats,
+        deletedMemories:deletedMemories,
+        failed:(emptyChats.length-deletedChats)
+            +(emptyMemories.size-deletedMemories)
+    };
+}
+
+function waitForDBOPFS(){
+    if(window.dbopfs?.ready){
+        return Promise.resolve(window.dbopfs);
+    }
+
+    return new Promise(
+        function waitForDBOPFSPromise(resolve){
+            function ready(){
+                window.removeEventListener('dbopfs-ready',ready);
+                resolve(window.dbopfs);
+            }
+
+            window.addEventListener('dbopfs-ready',ready);
+
+            if(window.dbopfs?.ready){
+                ready();
+            }
+        }
+    );
+}
+
+export {
+    clearEmptyChatsAndMemories,
+    hasMemoryContent,
+    hasUserEntry
+};

package/runtime/arcane/modules/DevelopmentWorkspace.js

@@ -0,0 +1,74 @@
+const ROOT_MAX_LENGTH=4096;
+const QUERY_MAX_LENGTH=4096;
+const TASK_ID_PATTERN=/^[a-z][a-z0-9-]{0,63}$/;
+
+function workspaceRoot(value){
+    const root=String(value??'').trim();
+    if(!root||root.length>ROOT_MAX_LENGTH||/[\u0000-\u001f]/.test(root)){
+        throw new TypeError('Choose one existing development workspace directory.');
+    }
+    return root;
+}
+
+function contextQuery(value){
+    const query=String(value??'').trim();
+    if(query.length>QUERY_MAX_LENGTH||/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/.test(query)){
+        throw new TypeError('Development context queries must be bounded plain text.');
+    }
+    return query;
+}
+
+function setupTaskId(value){
+    const taskId=String(value??'').trim().toLowerCase();
+    if(!TASK_ID_PATTERN.test(taskId)){
+        throw new TypeError('Choose a registered development setup task.');
+    }
+    return taskId;
+}
+
+/**
+ * Provider-neutral client for a native development-workspace capability.
+ *
+ * The provider owns filesystem authorization, canonical-path validation,
+ * context filtering, the setup-task allowlist, and an optional fixed Node.js
+ * prerequisite installer. This module never accepts an arbitrary command and
+ * never discovers workspaces on the user's machine.
+ */
+export default class DevelopmentWorkspace{
+    constructor(api=globalThis.Arcane?.development){
+        this.api=api||null;
+    }
+
+    get available(){
+        return Boolean(this.api?.inspect&&this.api?.context&&this.api?.setup);
+    }
+
+    get nodeInstallerAvailable(){
+        return Boolean(this.api?.installNode);
+    }
+
+    require(method){
+        if(!this.available||typeof this.api?.[method]!=='function'){
+            throw new Error('The Arcane development-workspace capability is unavailable. Open this application through an installed Arcane OS developer build.');
+        }
+        return this.api[method].bind(this.api);
+    }
+
+    inspect(root){
+        return this.require('inspect')(workspaceRoot(root));
+    }
+
+    context(root,query=''){
+        return this.require('context')(workspaceRoot(root),contextQuery(query));
+    }
+
+    setup(root,taskId){
+        return this.require('setup')(workspaceRoot(root),setupTaskId(taskId));
+    }
+
+    installNode(){
+        return this.require('installNode')();
+    }
+}
+
+export {contextQuery,setupTaskId,workspaceRoot};

package/runtime/arcane/modules/DirectoryPicker.js

@@ -0,0 +1,109 @@
+const TITLE_MAX_LENGTH=160;
+const PATH_MAX_LENGTH=4096;
+const CONTROL_CHARACTERS=/[\u0000-\u001f\u007f]/;
+
+function isPlainRecord(value){
+    return Boolean(value)
+        &&typeof value==='object'
+        &&!Array.isArray(value)
+        &&Object.getPrototypeOf(value)===Object.prototype;
+}
+
+function coded(error,code){
+    error.code=code;
+    return error;
+}
+
+function optionalText(value,label,maximum){
+    if(value===undefined||value===null||value==='') return null;
+    if(typeof value!=='string') throw new TypeError(`${label} must be a string when provided.`);
+    const normalized=value.trim();
+    if(!normalized) return null;
+    if(normalized.length>maximum) throw new RangeError(`${label} exceeds ${maximum} characters.`);
+    if(CONTROL_CHARACTERS.test(normalized)) throw new TypeError(`${label} cannot contain control characters.`);
+    return normalized;
+}
+
+function normalizeDirectoryPickerOptions(input={}){
+    if(!isPlainRecord(input)) throw new TypeError('Directory picker options must be a plain object.');
+    const allowed=new Set(['initialPath','title']);
+    const unsupported=Object.keys(input).find(key=>!allowed.has(key));
+    if(unsupported) throw new TypeError(`Unsupported directory picker option: ${unsupported}`);
+
+    const title=optionalText(input.title,'title',TITLE_MAX_LENGTH);
+    const initialPath=optionalText(input.initialPath,'initialPath',PATH_MAX_LENGTH);
+    return Object.freeze({
+        ...(title?{title}:{}),
+        ...(initialPath?{initialPath}:{}),
+    });
+}
+
+function normalizeDirectorySelection(input){
+    const keys=isPlainRecord(input)?Object.keys(input):[];
+    if(
+        !isPlainRecord(input)
+        ||keys.length!==2
+        ||!keys.includes('cancelled')
+        ||!keys.includes('path')
+        ||typeof input.cancelled!=='boolean'
+    ){
+        throw coded(
+            new TypeError('The directory picker provider returned an invalid result.'),
+            'DIRECTORY_PICKER_INVALID_RESULT',
+        );
+    }
+    if(input.cancelled){
+        if(input.path!==null){
+            throw coded(
+                new TypeError('A canceled directory selection must return a null path.'),
+                'DIRECTORY_PICKER_INVALID_RESULT',
+            );
+        }
+        return Object.freeze({cancelled:true,path:null});
+    }
+    let path;
+    try{
+        path=optionalText(input.path,'The selected directory path',PATH_MAX_LENGTH);
+    }catch(error){
+        throw coded(error,'DIRECTORY_PICKER_INVALID_RESULT');
+    }
+    if(!path){
+        throw coded(
+            new TypeError('The directory picker provider did not return a selected path.'),
+            'DIRECTORY_PICKER_INVALID_RESULT',
+        );
+    }
+    return Object.freeze({cancelled:false,path});
+}
+
+/**
+ * Opens a provider-owned operating-system directory selector.
+ *
+ * This wrapper does not enumerate directories, persist a selected path, or use
+ * a browser file picker. The injected provider must expose
+ * `selectDirectory(options)` and return `{cancelled, path}`.
+ */
+export default class DirectoryPicker{
+    constructor(provider=globalThis.Arcane?.filesystem){
+        this.provider=provider||null;
+    }
+
+    get available(){
+        return typeof this.provider?.selectDirectory==='function';
+    }
+
+    async select(options={}){
+        if(!this.available){
+            throw coded(
+                new Error('The Arcane directory selector is unavailable. Open this application through an installed Arcane OS build.'),
+                'DIRECTORY_PICKER_UNAVAILABLE',
+            );
+        }
+        const normalized=normalizeDirectoryPickerOptions(options);
+        return normalizeDirectorySelection(
+            await this.provider.selectDirectory({...normalized}),
+        );
+    }
+}
+
+export {normalizeDirectoryPickerOptions,normalizeDirectorySelection};

package/runtime/arcane/modules/DocumentNavigation.js

@@ -0,0 +1,223 @@
+const documentNavigationBindings=new WeakMap();
+const documentNavigationForms=new WeakSet();
+
+const navigationSelector='[data-document-navigation]';
+const filterSelector='[data-document-navigation-filter]';
+const itemSelector='[data-document-navigation-item]';
+const groupSelector='[data-document-navigation-group]';
+const clearSelector='[data-document-navigation-clear]';
+const statusSelector='[data-document-navigation-status]';
+const currentPageSelector='[aria-current="page"]';
+
+function normalizeNavigationSearch(value){
+    return String(value??'').trim().toLowerCase();
+}
+
+function navigationItemMatches(item,query){
+    if(query==='')return true;
+    const searchValue=normalizeNavigationSearch(item.getAttribute('data-navigation-search'));
+    return searchValue.includes(query);
+}
+
+function navigationGroupHasVisibleItem(group){
+    for(const item of group.querySelectorAll(itemSelector)){
+        if(!item.hidden)return true;
+    }
+    return false;
+}
+
+function documentNavigationStatusText(visibleCount,totalCount){
+    const noun=totalCount===1?'item':'items';
+    return `Showing ${visibleCount} of ${totalCount} ${noun}.`;
+}
+
+function updateDocumentNavigationStatus(status,visibleCount,totalCount){
+    if(!status)return;
+    status.textContent=documentNavigationStatusText(visibleCount,totalCount);
+}
+
+function nearestDocumentNavigationDetails(group){
+    return group.closest('details');
+}
+
+function documentNavigationDetailsIsOpen(details){
+    return typeof details.open==='boolean'
+        ?details.open
+        :details.hasAttribute('open');
+}
+
+function preserveDocumentNavigationDetails(binding){
+    binding.state.detailsOpen.clear();
+    for(const group of binding.groups){
+        const details=nearestDocumentNavigationDetails(group);
+        if(details&&!binding.state.detailsOpen.has(details)){
+            binding.state.detailsOpen.set(details,documentNavigationDetailsIsOpen(details));
+        }
+    }
+    binding.state.filtering=true;
+}
+
+function restoreDocumentNavigationDetails(binding){
+    for(const [details,wasOpen] of binding.state.detailsOpen){
+        details.open=wasOpen;
+    }
+    binding.state.detailsOpen.clear();
+    binding.state.filtering=false;
+}
+
+function applyDocumentNavigationFilter(binding){
+    const query=normalizeNavigationSearch(binding.filter.value);
+    const filtering=query!=='';
+    let visibleCount=0;
+
+    if(filtering&&!binding.state.filtering){
+        preserveDocumentNavigationDetails(binding);
+    }
+
+    for(const item of binding.items){
+        const visible=navigationItemMatches(item,query);
+        item.hidden=!visible;
+        if(visible)visibleCount+=1;
+    }
+
+    for(const group of binding.groups){
+        const visible=navigationGroupHasVisibleItem(group);
+        group.hidden=!visible;
+        if(filtering&&visible){
+            const details=nearestDocumentNavigationDetails(group);
+            if(details)details.open=true;
+        }
+    }
+
+    if(!filtering&&binding.state.filtering){
+        restoreDocumentNavigationDetails(binding);
+    }
+    if(binding.clearButton)binding.clearButton.hidden=!filtering;
+    updateDocumentNavigationStatus(binding.status,visibleCount,binding.items.length);
+    return visibleCount;
+}
+
+function clearDocumentNavigationFilter(binding,{focus=true}={}){
+    binding.filter.value='';
+    const visibleCount=applyDocumentNavigationFilter(binding);
+    if(focus)binding.filter.focus();
+    return visibleCount;
+}
+
+function preventDocumentNavigationSubmit(event){
+    event.preventDefault();
+}
+
+function revealCurrentDocumentNavigationItem(binding){
+    const currentItem=binding.navigation.querySelector(currentPageSelector);
+    if(
+        !currentItem
+        ||currentItem.hidden
+        ||typeof currentItem.getBoundingClientRect!=='function'
+        ||typeof binding.navigation.getBoundingClientRect!=='function'
+    )return false;
+
+    const navigationBounds=binding.navigation.getBoundingClientRect();
+    const itemBounds=currentItem.getBoundingClientRect();
+    if(
+        itemBounds.top>=navigationBounds.top
+        &&itemBounds.bottom<=navigationBounds.bottom
+    )return false;
+
+    const navigationCenter=(navigationBounds.top+navigationBounds.bottom)/2;
+    const itemCenter=(itemBounds.top+itemBounds.bottom)/2;
+    binding.navigation.scrollTop+=itemCenter-navigationCenter;
+    return true;
+}
+
+export function bindDocumentNavigation(navigation){
+    if(!navigation?.querySelector)return null;
+
+    const existingBinding=documentNavigationBindings.get(navigation);
+    if(existingBinding){
+        applyDocumentNavigationFilter(existingBinding);
+        return existingBinding;
+    }
+
+    const filter=navigation.querySelector(filterSelector);
+    if(!filter)return null;
+
+    const binding=Object.freeze({
+        clearButton:navigation.querySelector(clearSelector),
+        filter,
+        groups:Array.from(navigation.querySelectorAll(groupSelector)),
+        items:Array.from(navigation.querySelectorAll(itemSelector)),
+        navigation,
+        state:{detailsOpen:new Map(),filtering:false},
+        status:navigation.querySelector(statusSelector)
+    });
+
+    function handleDocumentNavigationInput(){
+        applyDocumentNavigationFilter(binding);
+    }
+
+    function handleDocumentNavigationKeydown(event){
+        if(event.key!=='Escape')return;
+        event.preventDefault();
+        clearDocumentNavigationFilter(binding);
+    }
+
+    function handleDocumentNavigationClear(event){
+        event.preventDefault();
+        clearDocumentNavigationFilter(binding);
+    }
+
+    filter.addEventListener('input',handleDocumentNavigationInput);
+    filter.addEventListener('keydown',handleDocumentNavigationKeydown);
+    binding.clearButton?.addEventListener('click',handleDocumentNavigationClear);
+
+    const form=filter.closest('form');
+    if(form&&!documentNavigationForms.has(form)){
+        form.addEventListener('submit',preventDocumentNavigationSubmit);
+        documentNavigationForms.add(form);
+    }
+
+    documentNavigationBindings.set(navigation,binding);
+    applyDocumentNavigationFilter(binding);
+    revealCurrentDocumentNavigationItem(binding);
+    return binding;
+}
+
+export function initializeDocumentNavigation(root=globalThis.document){
+    if(!root?.querySelectorAll)return [];
+
+    const navigations=[];
+    if(root.matches?.(navigationSelector))navigations.push(root);
+    for(const navigation of root.querySelectorAll(navigationSelector)){
+        navigations.push(navigation);
+    }
+
+    const bindings=[];
+    for(const navigation of navigations){
+        const binding=bindDocumentNavigation(navigation);
+        if(binding)bindings.push(binding);
+    }
+    return bindings;
+}
+
+function autoInitializeDocumentNavigation(){
+    initializeDocumentNavigation(globalThis.document);
+}
+
+if(typeof globalThis.document!=='undefined'){
+    if(globalThis.document.readyState==='loading'){
+        globalThis.document.addEventListener(
+            'DOMContentLoaded',
+            autoInitializeDocumentNavigation,
+            {once:true}
+        );
+    }else{
+        autoInitializeDocumentNavigation();
+    }
+}
+
+export {
+    applyDocumentNavigationFilter,
+    clearDocumentNavigationFilter,
+    revealCurrentDocumentNavigationItem
+};