arcane-os 0.1.0-dev.5

package/runtime/arcane/modules/GifEncoder.js

@@ -0,0 +1,29 @@
+const ascii=value=>Array.from(value,char=>char.charCodeAt(0));
+const word=value=>[value&255,(value>>8)&255];
+
+function palette(){const bytes=[];for(let index=0;index<256;index++){bytes.push(((index>>5)&7)*255/7,((index>>2)&7)*255/7,(index&3)*255/3)}return bytes.map(Math.round)}
+function indexPixels(data){const result=new Uint8Array(data.length/4);for(let offset=0,index=0;offset<data.length;offset+=4,index++)result[index]=((data[offset]>>5)<<5)|((data[offset+1]>>5)<<2)|(data[offset+2]>>6);return result;}
+
+function lzw(indices){
+    const clear=256,end=257,bytes=[];let bits=0,bitCount=0,codeSize=9,next=258,table=new Map();
+    const write=code=>{bits|=code<<bitCount;bitCount+=codeSize;while(bitCount>=8){bytes.push(bits&255);bits>>>=8;bitCount-=8}};
+    const reset=()=>{table=new Map();codeSize=9;next=258};write(clear);let prefix=indices[0]??0;
+    for(let position=1;position<indices.length;position++){
+        const symbol=indices[position],key=`${prefix},${symbol}`;
+        if(table.has(key)){prefix=table.get(key);continue}
+        write(prefix);
+        if(next<4096){table.set(key,next++);if(next===(1<<codeSize)&&codeSize<12)codeSize++}
+        else{write(clear);reset()}
+        prefix=symbol;
+    }
+    write(prefix);write(end);if(bitCount)bytes.push(bits&255);return bytes;
+}
+function blocks(data){const result=[];for(let index=0;index<data.length;index+=255){const block=data.slice(index,index+255);result.push(block.length,...block)}result.push(0);return result;}
+
+export default class GifEncoder{
+    constructor(width,height,{loop=0}={}){this.width=Math.max(1,Math.trunc(width));this.height=Math.max(1,Math.trunc(height));this.loop=Math.max(0,Math.trunc(loop));this.frames=[];}
+    addFrame(imageData,{delay=250}={}){if(imageData.width!==this.width||imageData.height!==this.height)throw new RangeError('GIF frame dimensions must match the encoder.');this.frames.push({pixels:indexPixels(imageData.data),delay:Math.max(2,Math.round(delay/10))});return this.frames.length;}
+    encode(){if(!this.frames.length)throw new Error('A GIF requires at least one frame.');const bytes=[...ascii('GIF89a'),...word(this.width),...word(this.height),0xF7,0,0,...palette(),0x21,0xFF,0x0B,...ascii('NETSCAPE2.0'),0x03,0x01,...word(this.loop),0];for(const frame of this.frames){bytes.push(0x21,0xF9,0x04,0x04,...word(frame.delay),0,0,0x2C,0,0,0,0,...word(this.width),...word(this.height),0,8,...blocks(lzw(frame.pixels)))}bytes.push(0x3B);return new Blob([new Uint8Array(bytes)],{type:'image/gif'});}
+}
+
+export {indexPixels,lzw};

package/runtime/arcane/modules/HTMLImport.js

@@ -0,0 +1,114 @@
+const htmlImportHostRegistryKey=Symbol.for('arcane.html-import.hosts');
+const htmlImportHostRegistry=globalThis[htmlImportHostRegistryKey] instanceof Map
+  ?globalThis[htmlImportHostRegistryKey]
+  :new Map();
+
+globalThis[htmlImportHostRegistryKey]=htmlImportHostRegistry;
+
+let htmlImportScriptId=0;
+
+class HTMLImport extends HTMLElement {
+  ready=false;
+
+  constructor() {
+      super();
+      this.attachShadow({ mode: 'open' });
+  }
+
+  async connectedCallback() {
+    this.ready=false;
+    const href=this.getAttribute('href');
+    let resolvedHref='';
+    if(!href){
+      console.log('no href provided for html-import tag',this);
+      return;
+    }
+
+    try{
+      const baseURL=new URL(document.baseURI);
+      const resolvedURL=new URL(href,baseURL);
+      resolvedHref=resolvedURL.href;
+      if(resolvedURL.origin!==baseURL.origin){
+        throw new Error('HTML imports must use a same-origin URL.');
+      }
+      const response=await fetch(resolvedURL.href,{
+        cache:'default',
+        credentials:'same-origin',
+        method:'GET',
+        redirect:'error'
+      });
+      await this.#loadHTML(href,resolvedHref,response);
+    }catch(err){
+      console.error('Error loading HTML component:',err);
+      this.dispatchEvent(new CustomEvent('html-import-error',{
+        bubbles:true,
+        composed:true,
+        detail:{
+          code:'HTML_IMPORT_FAILED',
+          href,
+          message:'The component could not be loaded.',
+          resolvedHref
+        }
+      }));
+    }
+  }
+
+  async #loadHTML(href,resolvedHref,response){
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+
+    const html = await response.text();
+    this.shadowRoot.innerHTML = html;
+
+    await this.#executeScripts();
+
+    this.ready=true;
+    this.dispatchEvent(new CustomEvent('html-import-ready',{
+      bubbles:true,
+      composed:true,
+      detail:{href,resolvedHref}
+    }));
+    return true;
+  }
+
+  async #executeScripts() {
+    const scripts = Array.from(this.shadowRoot.querySelectorAll('script'));
+    for(const script of scripts){
+        if (script.src) {
+          console.error('ONLY INLINE SCRIPTS SUPPORTED AT THIS TIME FOR SECURITY REASONS');
+          console.warn('script src path will need to be limited to ./{text}.js, ../{text}.js), or acceptable sub folders. This can be complex.');
+          return;
+          //newScript.src = script.src;
+        }
+
+        const source=(script.textContent||'').replace(
+          /\bimport\s*\(\s*(['"])(\.{1,2}\/[^'"]+)\1\s*\)/g,
+          (_match,_quote,specifier)=>{
+            return `import(${JSON.stringify(new URL(specifier,import.meta.url).href)})`;
+          }
+        );
+        const executable=document.createElement('script');
+        const hostToken=`html-import-${Date.now()}-${htmlImportScriptId++}`;
+
+        executable.dataset.arcaneHostToken=hostToken;
+        executable.textContent=`(()=>{const registry=globalThis[Symbol.for('arcane.html-import.hosts')];const token=document.currentScript&&document.currentScript.dataset.arcaneHostToken;const binding=registry instanceof Map&&token?registry.get(token):null;if(!binding?.host)throw new Error('HTML import host binding is unavailable.');binding.promise=(async function(){${source}}).call(binding.host);})()`;
+        script.parentNode.removeChild(script);
+
+        const binding={host:this,promise:null};
+        htmlImportHostRegistry.set(hostToken,binding);
+        try{
+          document.head.appendChild(executable);
+          await binding.promise;
+        }finally{
+          executable.remove();
+          htmlImportHostRegistry.delete(hostToken);
+          delete executable.dataset.arcaneHostToken;
+        }
+    }
+  }
+}
+  
+customElements.define('html-import', HTMLImport);
+
+export default HTMLImport;

package/runtime/arcane/modules/InMemoryCommunicationProvider.js

@@ -0,0 +1,14 @@
+import CommunicationMessage from '../entities/CommunicationMessage.js';
+import CommunicationThread from '../entities/CommunicationThread.js';
+
+export default class InMemoryCommunicationProvider{
+    constructor({id='demo-provider',label='Demo provider',channels=['other'],threads=[],messages={}}={}){
+        this.id=String(id);this.label=String(label);this.channels=Object.freeze(Array.from(channels,String));
+        this.threadRecords=Array.from(threads,value=>value instanceof CommunicationThread?value:new CommunicationThread({...value,providerId:this.id}));
+        this.messageRecords=new Map(Object.entries(messages).map(([threadId,values])=>[threadId,Array.from(values,item=>item instanceof CommunicationMessage?item:new CommunicationMessage({...item,threadId,providerId:this.id}))]));
+        this.sequence=0;
+    }
+    async listThreads(){return this.threadRecords.map(thread=>new CommunicationThread(thread.toJSON()));}
+    async getMessages(threadId){return Array.from(this.messageRecords.get(String(threadId))||[],message=>new CommunicationMessage(message.toJSON()));}
+    async send({threadId,channel='other',body,recipients=[]}={}){const id=`demo-outbound-${++this.sequence}`,records=this.messageRecords.get(String(threadId))||[],latest=records.reduce((value,item)=>Math.max(value,new Date(item.timestamp).valueOf()),0),timestamp=new Date(Math.max(Date.now(),latest+1)).toISOString(),message=new CommunicationMessage({id,threadId,providerId:this.id,channel,direction:'outbound',body,recipients,timestamp,status:'sent'});records.push(message);this.messageRecords.set(String(threadId),records);return new CommunicationMessage(message.toJSON());}
+}

package/runtime/arcane/modules/IsolatedModelQuestionRunner.js

@@ -0,0 +1,275 @@
+const MODEL_EVIDENCE_KEYS=Object.freeze([
+    'id',
+    'name',
+    'provider',
+    'digest',
+    'sizeBytes',
+    'modifiedAt'
+]);
+const RUN_REQUEST_KEYS=Object.freeze([
+    'model',
+    'prompt',
+    'systemPrompt',
+    'options',
+    'expectedModel'
+]);
+const RUN_REQUEST_OPTIONAL_KEYS=Object.freeze(['onPhase','think']);
+const THINK_LEVELS=Object.freeze(['low','medium','high']);
+const SENTENCE_BOUNDARY=/[.!?]+(?:["'\u2019\u201d)\]}]+)?(?=\s|$)/gu;
+const WORD_OR_NUMBER=/[\p{L}\p{N}]/u;
+
+function codedError(code,message,ErrorType=Error){
+    const error=new ErrorType(message);
+    error.code=code;
+    return error;
+}
+
+function isPlainRecord(value){
+    return Boolean(value)
+        &&typeof value==='object'
+        &&!Array.isArray(value)
+        &&Object.getPrototypeOf(value)===Object.prototype;
+}
+
+function hasExactKeys(value,required,optional=[]){
+    if(!isPlainRecord(value)){
+        return false;
+    }
+    const requiredSet=new Set(required);
+    const allowed=new Set([...required,...optional]);
+    const keys=Object.keys(value);
+    return required.every(function requiredKey(key){return Object.hasOwn(value,key);})
+        &&keys.every(function allowedKey(key){return allowed.has(key);})
+        &&keys.filter(function requiredKey(key){return requiredSet.has(key);}).length===required.length;
+}
+
+function exactTimestamp(value){
+    if(typeof value!=='string'){
+        return null;
+    }
+    const milliseconds=Date.parse(value);
+    if(!Number.isFinite(milliseconds)||new Date(milliseconds).toISOString()!==value){
+        return null;
+    }
+    return milliseconds;
+}
+
+function validModifiedAt(value){
+    return value===null||(typeof value==='string'&&Number.isFinite(Date.parse(value)));
+}
+
+function validateExpectedModel(model,expectedModel){
+    const valid=typeof model==='string'
+        &&model.length>0
+        &&model===model.trim()
+        &&hasExactKeys(expectedModel,MODEL_EVIDENCE_KEYS)
+        &&expectedModel.id===model
+        &&expectedModel.name===model
+        &&expectedModel.provider==='ollama'
+        &&/^[a-f0-9]{64}$/i.test(expectedModel.digest)
+        &&Number.isSafeInteger(expectedModel.sizeBytes)
+        &&expectedModel.sizeBytes>0
+        &&validModifiedAt(expectedModel.modifiedAt);
+    if(!valid){
+        throw codedError(
+            'INVALID_ISOLATED_MODEL_RUNNER_REQUEST',
+            'The isolated-model request requires exact authoritative model evidence.',
+            TypeError
+        );
+    }
+}
+
+function sameModelEvidence(actual,expected){
+    return hasExactKeys(actual,MODEL_EVIDENCE_KEYS)
+        &&MODEL_EVIDENCE_KEYS.every(function matchingField(field){
+            return actual[field]===expected[field];
+        });
+}
+
+function validDefaults(value){
+    return hasExactKeys(value,['systemPromptPresent','messageCount'])
+        &&value.systemPromptPresent===false
+        &&value.messageCount===0;
+}
+
+function invalidProof(message){
+    throw codedError(
+        'ARCANE_ISOLATED_MODEL_PROOF_INVALID',
+        message||'Arcane Core returned an invalid isolated-model proof.'
+    );
+}
+
+function validateInspection(result,expectedModel,contextTokens){
+    if(!hasExactKeys(result,['schemaVersion','model','defaults','admission'])
+        ||result.schemaVersion!==1
+        ||!sameModelEvidence(result.model,expectedModel)
+        ||!validDefaults(result.defaults)
+        ||!isPlainRecord(result.admission)
+        ||result.admission.admitted!==true
+        ||result.admission.contextTokens!==contextTokens){
+        invalidProof('Arcane Core returned an invalid isolated-model inspection proof.');
+    }
+    return result;
+}
+
+function validateAbsenceProof(value){
+    return hasExactKeys(value,['absent','observedAt','polls'])
+        &&value.absent===true
+        &&exactTimestamp(value.observedAt)!==null
+        &&Number.isSafeInteger(value.polls)
+        &&value.polls>0;
+}
+
+function validateIsolation(value){
+    if(!hasExactKeys(value,['pre','post','keepAlive','messageCount','defaults'])
+        ||!validateAbsenceProof(value.pre)
+        ||!validateAbsenceProof(value.post)
+        ||exactTimestamp(value.pre.observedAt)>exactTimestamp(value.post.observedAt)
+        ||value.keepAlive!==0
+        ||value.messageCount!==2
+        ||!validDefaults(value.defaults)){
+        invalidProof('Arcane Core did not prove the required isolated-model lifecycle.');
+    }
+    return value;
+}
+
+function validateRunResult(result,expectedModel){
+    if(!hasExactKeys(result,[
+        'schemaVersion',
+        'model',
+        'answer',
+        'startedAt',
+        'completedAt',
+        'elapsedMs',
+        'isolation'
+    ])
+        ||result.schemaVersion!==1
+        ||!sameModelEvidence(result.model,expectedModel)
+        ||typeof result.answer!=='string'){
+        invalidProof('Arcane Core returned an invalid isolated-model response.');
+    }
+    const started=exactTimestamp(result.startedAt);
+    const completed=exactTimestamp(result.completedAt);
+    if(started===null
+        ||completed===null
+        ||completed<started
+        ||!Number.isFinite(result.elapsedMs)
+        ||result.elapsedMs<0){
+        invalidProof('Arcane Core returned invalid isolated-model timing evidence.');
+    }
+    validateIsolation(result.isolation);
+    return result;
+}
+
+/**
+ * Counts terminal sentence-punctuation groups and one final unpunctuated
+ * fragment. The heuristic is deliberately deterministic and never rewrites
+ * the response it observes.
+ */
+function countSentences(value){
+    if(typeof value!=='string'){
+        throw new TypeError('Sentence counting requires a string.');
+    }
+    const text=value.trim();
+    if(!text){
+        return 0;
+    }
+    let count=0;
+    let consumed=0;
+    SENTENCE_BOUNDARY.lastIndex=0;
+    for(const match of text.matchAll(SENTENCE_BOUNDARY)){
+        count+=1;
+        consumed=Number(match.index)+match[0].length;
+    }
+    const trailing=text.slice(consumed).trim();
+    if(trailing&&(count===0||WORD_OR_NUMBER.test(trailing))){
+        count+=1;
+    }
+    return count;
+}
+
+function requireLocalAI(localAI){
+    if(!localAI
+        ||typeof localAI.inspectIsolatedModel!=='function'
+        ||typeof localAI.runIsolatedQuestion!=='function'){
+        throw codedError(
+            'ARCANE_ISOLATED_MODEL_API_UNAVAILABLE',
+            'The Arcane isolated-model API is unavailable. Open this application through a compatible Arcane OS host.'
+        );
+    }
+    return localAI;
+}
+
+class IsolatedModelQuestionRunner{
+    constructor({localAI,maxSentences=5}={}){
+        if(!Number.isSafeInteger(maxSentences)||maxSentences<1||maxSentences>100){
+            throw new RangeError('maxSentences must be an integer from 1 through 100.');
+        }
+        this.localAI=requireLocalAI(localAI);
+        this.maxSentences=maxSentences;
+    }
+
+    async inspectModel(model,expectedModel,contextTokens){
+        validateExpectedModel(model,expectedModel);
+        if(!Number.isSafeInteger(contextTokens)||contextTokens<1024||contextTokens>262144){
+            throw codedError(
+                'INVALID_ISOLATED_MODEL_RUNNER_REQUEST',
+                'The isolated-model inspection requires a context from 1,024 through 262,144 tokens.',
+                RangeError
+            );
+        }
+        const result=await this.localAI.inspectIsolatedModel({model,expectedModel,contextTokens});
+        return validateInspection(result,expectedModel,contextTokens);
+    }
+
+    async runQuestion(input={}){
+        if(!hasExactKeys(input,RUN_REQUEST_KEYS,RUN_REQUEST_OPTIONAL_KEYS)){
+            throw codedError(
+                'INVALID_ISOLATED_MODEL_RUNNER_REQUEST',
+                'The isolated-model question request has unsupported or missing fields.',
+                TypeError
+            );
+        }
+        const {model,prompt,systemPrompt,options,think,expectedModel,onPhase}=input;
+        const hasThink=Object.hasOwn(input,'think');
+        validateExpectedModel(model,expectedModel);
+        if(typeof prompt!=='string'
+            ||typeof systemPrompt!=='string'
+            ||!isPlainRecord(options)
+            ||(hasThink&&!THINK_LEVELS.includes(think))
+            ||(onPhase!==undefined&&typeof onPhase!=='function')){
+            throw codedError(
+                'INVALID_ISOLATED_MODEL_RUNNER_REQUEST',
+                'The isolated-model question request contains invalid values.',
+                TypeError
+            );
+        }
+        const request={
+            model,
+            prompt,
+            systemPrompt,
+            options,
+            ...(hasThink?{think}:{}),
+            expectedModel
+        };
+        const streamOptions=onPhase===undefined?{}:{onPhase};
+        const result=validateRunResult(
+            await this.localAI.runIsolatedQuestion(request,streamOptions),
+            expectedModel
+        );
+        const sentenceCount=countSentences(result.answer);
+        return Object.freeze({
+            answer:result.answer,
+            startedAt:result.startedAt,
+            completedAt:result.completedAt,
+            elapsedMs:result.elapsedMs,
+            isolation:result.isolation,
+            model:result.model,
+            sentenceCount,
+            sentenceLimitExceeded:sentenceCount>this.maxSentences
+        });
+    }
+}
+
+export {IsolatedModelQuestionRunner,countSentences};
+export default IsolatedModelQuestionRunner;