arcane-os 0.3.1 → 0.3.2

package/runtime/arcane/modules/DocumentLexicalSearch.js

@@ -1,7 +1,7 @@
-const DOCUMENT_SEARCH_FIELD_ORDER=Object.freeze([
+const DOCUMENT_SEARCH_FIELD_ORDER=[
     'title','searchTerms','tags','headings','summary','category','navigationGroup',
     'navigationParent','audiences','platforms','sourcePath','path','language','id'
-]);
+];
 const SEARCH_STOP_WORDS=new Set([
     'a','an','and','are','as','at','be','by','do','does','for','from','how','i',
     'in','is','it','of','on','or','that','the','this','to','use','using','what',
@@ -28,8 +28,7 @@ function normalizedDocumentSearchText(value){
 
 function documentSearchTokens(value){
     return [...new Set(normalizedDocumentSearchText(value).match(/[\p{L}\p{N}]+/gu)??[])]
-        .filter(token=>!SEARCH_STOP_WORDS.has(token))
-        .slice(0,32);
+        .filter(token=>!SEARCH_STOP_WORDS.has(token));
 }
 
 function list(value,mapper=normalizedDocumentSearchText){
@@ -38,7 +37,7 @@ function list(value,mapper=normalizedDocumentSearchText){
 
 function createDocumentLexicalIndex(record){
     if(!isPlainRecord(record)) fail('Document search records must be plain objects.');
-    return Object.freeze({
+    return {
         audiences:list(record.audiences),
         category:normalizedDocumentSearchText(record.category),
         headings:list(record.headings,heading=>normalizedDocumentSearchText(heading?.text)),
@@ -53,7 +52,7 @@ function createDocumentLexicalIndex(record){
         summary:normalizedDocumentSearchText(record.summary),
         tags:list(record.tags),
         title:normalizedDocumentSearchText(record.title),
-    });
+    };
 }
 
 function scoreDocumentLexicalIndex(index,phrase,tokens){
@@ -104,7 +103,7 @@ function scoreDocumentLexicalIndex(index,phrase,tokens){
         if(index.path.includes(token)){score+=4;matched.add('path');}
         if(index.id.includes(token)){score+=5;matched.add('id');}
     }
-    return Object.freeze({matched,score});
+    return {matched,score};
 }
 
 function scoreDocumentBody(value,phrase,tokens){
@@ -125,77 +124,26 @@ function compareText(left,right){
     return left<right?-1:left>right?1:0;
 }
 
-function boundedSearchResults(results,limit){
-    if(results.length<=limit) return results;
-    const collectionLimit=Math.max(1,Math.floor(limit/4));
-    const collectionCounts=new Map();
-    const selected=new Set();
-    const deferred=[];
-    for(const result of results){
-        if(selected.size>=limit) break;
-        if(!result.navigationParent){selected.add(result);continue;}
-        const parent=canonicalKey(result.navigationParent);
-        const count=collectionCounts.get(parent)??0;
-        if(count>=collectionLimit){deferred.push(result);continue;}
-        collectionCounts.set(parent,count+1);
-        selected.add(result);
-    }
-    for(const result of deferred){
-        if(selected.size>=limit) break;
-        selected.add(result);
-    }
-    return results.filter(result=>selected.has(result));
-}
-
 function normalizeQuery(value){
     if(typeof value!=='string') fail('Search query must be a string.','DOCUMENT_SEARCH_INVALID_QUERY');
     const query=value.trim();
-    if(query.length>512||CONTROL_CHARACTERS.test(query)){
-        fail('Search query must be bounded plain text.','DOCUMENT_SEARCH_INVALID_QUERY');
+    if(CONTROL_CHARACTERS.test(query)){
+        fail('Search query must be plain text.','DOCUMENT_SEARCH_INVALID_QUERY');
     }
     return query;
 }
 
 function normalizeFilter(value,label){
     if(value===undefined) return null;
-    if(!Array.isArray(value)||value.length>64) fail(`${label} must be a bounded array.`,'DOCUMENT_SEARCH_INVALID_QUERY');
+    if(!Array.isArray(value)) fail(`${label} must be an array.`,'DOCUMENT_SEARCH_INVALID_QUERY');
     return new Set(value.map((item,index)=>{
-        if(typeof item!=='string'||!item.trim()||item.length>64){
-            fail(`${label} entry ${index+1} must be bounded text.`,'DOCUMENT_SEARCH_INVALID_QUERY');
+        if(typeof item!=='string'||!item.trim()){
+            fail(`${label} entry ${index+1} must contain text.`,'DOCUMENT_SEARCH_INVALID_QUERY');
         }
         return canonicalKey(item.trim());
     }));
 }
 
-function safeSlice(value,maximum){
-    if(value.length<=maximum) return value;
-    let end=maximum;
-    const code=value.charCodeAt(end-1);
-    if(code>=0xd800&&code<=0xdbff) end--;
-    return value.slice(0,end);
-}
-
-function relevantSliceStart(value,query,maximum){
-    if(value.length<=maximum) return 0;
-    const phrase=String(query||'').trim().toLowerCase();
-    const tokens=documentSearchTokens(query);
-    const body=value.toLowerCase();
-    const positions=[phrase,...tokens]
-        .filter(Boolean)
-        .map(term=>body.indexOf(term))
-        .filter(index=>index>=0);
-    const match=positions.length?Math.min(...positions):0;
-    let start=Math.max(0,match-Math.floor(maximum/3));
-    const priorNewline=start>0?value.lastIndexOf('\n',start-1):-1;
-    const alignedStart=priorNewline+1;
-    if(match-alignedStart<=Math.floor(maximum*2/3)) start=alignedStart;
-    if(start>0){
-        const code=value.charCodeAt(start);
-        if(code>=0xdc00&&code<=0xdfff) start++;
-    }
-    return start;
-}
-
 function lineNumberAt(value,offset){
     let line=1;
     let cursor=value.indexOf('\n');
@@ -203,33 +151,23 @@ function lineNumberAt(value,offset){
     return line;
 }
 
-function documentContextExcerpt(value,query,maximum,{relevant=false}={}){
+function documentContextExcerpt(value){
     if(typeof value!=='string') fail('Document context must be text.');
-    if(!Number.isSafeInteger(maximum)||maximum<1) fail('Document context limit must be a positive integer.');
-    const start=relevant?relevantSliceStart(value,query,maximum):0;
-    const text=safeSlice(value.slice(start),maximum);
-    const end=start+text.length;
-    return Object.freeze({
-        lineEnd:lineNumberAt(value,Math.max(start,end-1)),
-        lineStart:lineNumberAt(value,start),
-        text,
-        truncated:start>0||end<value.length,
-    });
+    return {
+        lineEnd:lineNumberAt(value,Math.max(0,value.length-1)),
+        lineStart:1,
+        text:value,
+    };
 }
 
 class DocumentLexicalSearch{
     #indexes;
-    #maxResults;
     #records;
 
-    constructor(records,{maxResults=20}={}){
+    constructor(records){
         if(!Array.isArray(records)) fail('Document search records must be an array.');
-        if(!Number.isSafeInteger(maxResults)||maxResults<1||maxResults>100){
-            fail('maxResults must be an integer from 1 through 100.');
-        }
-        this.#records=Object.freeze([...records]);
+        this.#records=[...records];
         this.#indexes=new Map(this.#records.map(record=>[record.id,createDocumentLexicalIndex(record)]));
-        this.#maxResults=maxResults;
     }
 
     rank(query,options={}){
@@ -249,32 +187,28 @@ class DocumentLexicalSearch{
                 ?scoreDocumentLexicalIndex(this.#indexes.get(record.id),phrase,tokens)
                 :{matched:new Set(),score:0};
             if(text&&!score) continue;
-            results.push(Object.freeze({
+            results.push({
                 ...record,
-                matchedFields:Object.freeze(DOCUMENT_SEARCH_FIELD_ORDER.filter(field=>matched.has(field))),
+                matchedFields:DOCUMENT_SEARCH_FIELD_ORDER.filter(field=>matched.has(field)),
                 score,
-            }));
+            });
         }
         results.sort((left,right)=>
             right.score-left.score
             ||compareText(normalizedDocumentSearchText(left.title),normalizedDocumentSearchText(right.title))
             ||compareText(String(left.id),String(right.id))
         );
-        return Object.freeze(results);
+        return results;
     }
 
     search(query,options={}){
         if(!isPlainRecord(options)) fail('Search options must be a plain object.','DOCUMENT_SEARCH_INVALID_QUERY');
         const unknown=Object.keys(options).find(key=>!['kinds','limit','tags'].includes(key));
         if(unknown) fail(`Search options contain an unsupported field: ${unknown}.`,'DOCUMENT_SEARCH_INVALID_QUERY');
-        const limit=options.limit??this.#maxResults;
-        if(!Number.isSafeInteger(limit)||limit<1||limit>this.#maxResults){
-            fail(`Search result limit must be an integer from 1 through ${this.#maxResults}.`,'DOCUMENT_SEARCH_INVALID_QUERY');
-        }
-        return Object.freeze(boundedSearchResults(this.rank(query,{
+        return this.rank(query,{
             kinds:options.kinds,
             tags:options.tags,
-        }),limit));
+        });
     }
 }
 

package/runtime/arcane/modules/HTMLImport.js

@@ -12,6 +12,59 @@ globalThis[htmlImportHostRegistryKey]=htmlImportHostRegistry;
 
 let htmlImportScriptId=0;
 
+function componentRuntimeRoot(resolvedHref){
+  const componentURL=new URL(resolvedHref);
+  const componentMarker='/arcane/components/';
+  const componentIndex=componentURL.pathname.lastIndexOf(componentMarker);
+  if(componentIndex<0)return null;
+  const runtimePath=componentURL.pathname.slice(
+    0,
+    componentIndex+'/arcane/'.length
+  );
+  return new URL(runtimePath,componentURL.origin);
+}
+
+function resolveComponentResource(value,runtimeRoot){
+  if(!runtimeRoot||typeof value!=='string'||!value.startsWith('./arcane/')){
+    return value;
+  }
+  return new URL(value.slice('./arcane/'.length),runtimeRoot).href;
+}
+
+function resolveComponentStyleResources(styleText,runtimeRoot){
+  if(!runtimeRoot)return styleText;
+  return styleText.replace(
+    /url\(\s*(['"]?)\.\/arcane\/([^)'"\s]+)\1\s*\)/gu,
+    function resolveStyleURL(_match,quote,resourcePath){
+      const resolved=new URL(resourcePath,runtimeRoot).href;
+      return `url(${quote}${resolved}${quote})`;
+    }
+  );
+}
+
+function createComponentFragment(html,resolvedHref){
+  const template=document.createElement('template');
+  template.innerHTML=html;
+  const runtimeRoot=componentRuntimeRoot(resolvedHref);
+  if(!runtimeRoot)return template.content;
+
+  for(const element of template.content.querySelectorAll('[href],[src]')){
+    for(const attribute of ['href','src']){
+      if(!element.hasAttribute(attribute))continue;
+      const value=element.getAttribute(attribute);
+      const resolved=resolveComponentResource(value,runtimeRoot);
+      if(resolved!==value)element.setAttribute(attribute,resolved);
+    }
+  }
+  for(const style of template.content.querySelectorAll('style')){
+    style.textContent=resolveComponentStyleResources(
+      style.textContent||'',
+      runtimeRoot
+    );
+  }
+  return template.content;
+}
+
 function samePropertyDescriptor(left,right){
   if(!left||!right)return left===right;
   return left.configurable===right.configurable
@@ -219,7 +272,7 @@ class HTMLImport extends HTMLElement {
     if(!this.#isCurrentConnection(generation,controller))return false;
     await this.#destroyImportedHost();
     if(!this.#isCurrentConnection(generation,controller))return false;
-    this.shadowRoot.innerHTML = html;
+    this.shadowRoot.replaceChildren(createComponentFragment(html,resolvedHref));
 
     await this.#executeScripts();
     if(!this.#isCurrentConnection(generation,controller)){

package/runtime/arcane/modules/IsolatedModelQuestionRunner.js

@@ -1,22 +1,5 @@
-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;
+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);
@@ -27,162 +10,25 @@ function codedError(code,message,ErrorType=Error){
 function isPlainRecord(value){
     return Boolean(value)
         &&typeof value==='object'
-        &&!Array.isArray(value)
-        &&Object.getPrototypeOf(value)===Object.prototype;
+        &&!Array.isArray(value);
 }
 
-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){
+    if(!value.trim()){
         return 0;
     }
     let count=0;
     let consumed=0;
     SENTENCE_BOUNDARY.lastIndex=0;
-    for(const match of text.matchAll(SENTENCE_BOUNDARY)){
+    for(const match of value.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))){
+    const trailing=value.slice(consumed);
+    if(trailing.trim()&&(count===0||WORD_OR_NUMBER.test(trailing))){
         count+=1;
     }
     return count;
@@ -201,42 +47,45 @@ function requireLocalAI(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.');
-        }
+    constructor({localAI}={}){
         this.localAI=requireLocalAI(localAI);
-        this.maxSentences=maxSentences;
     }
 
     async inspectModel(model,expectedModel,contextTokens){
-        validateExpectedModel(model,expectedModel);
-        if(!Number.isSafeInteger(contextTokens)||contextTokens<1024||contextTokens>262144){
+        if(typeof model!=='string'||!model.trim()){
             throw codedError(
                 'INVALID_ISOLATED_MODEL_RUNNER_REQUEST',
-                'The isolated-model inspection requires a context from 1,024 through 262,144 tokens.',
+                'The isolated-model inspection requires a model.',
+                TypeError
+            );
+        }
+        if(contextTokens!==undefined&&(!Number.isSafeInteger(contextTokens)||contextTokens<1)){
+            throw codedError(
+                'INVALID_ISOLATED_MODEL_RUNNER_REQUEST',
+                'The isolated-model inspection context token value must be positive when provided.',
                 RangeError
             );
         }
-        const result=await this.localAI.inspectIsolatedModel({model,expectedModel,contextTokens});
-        return validateInspection(result,expectedModel,contextTokens);
+        const request={model};
+        if(expectedModel!==undefined)request.expectedModel=expectedModel;
+        if(contextTokens!==undefined)request.contextTokens=contextTokens;
+        return this.localAI.inspectIsolatedModel(request);
     }
 
     async runQuestion(input={}){
-        if(!hasExactKeys(input,RUN_REQUEST_KEYS,RUN_REQUEST_OPTIONAL_KEYS)){
+        if(!isPlainRecord(input)){
             throw codedError(
                 'INVALID_ISOLATED_MODEL_RUNNER_REQUEST',
-                'The isolated-model question request has unsupported or missing fields.',
+                'The isolated-model question request must be an object.',
                 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))
+        const {onPhase,...request}=input;
+        if(typeof request.model!=='string'
+            ||!request.model.trim()
+            ||typeof request.prompt!=='string'
+            ||(Object.hasOwn(request,'systemPrompt')&&typeof request.systemPrompt!=='string')
+            ||(Object.hasOwn(request,'options')&&!isPlainRecord(request.options))
             ||(onPhase!==undefined&&typeof onPhase!=='function')){
             throw codedError(
                 'INVALID_ISOLATED_MODEL_RUNNER_REQUEST',
@@ -244,30 +93,18 @@ class IsolatedModelQuestionRunner{
                 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
-        });
+        const result=await this.localAI.runIsolatedQuestion(request,streamOptions);
+        if(!isPlainRecord(result)||typeof result.answer!=='string'){
+            throw codedError(
+                'ARCANE_ISOLATED_MODEL_RESPONSE_INVALID',
+                'Arcane Core returned an invalid isolated-model response.'
+            );
+        }
+        return {
+            ...result,
+            sentenceCount:countSentences(result.answer)
+        };
     }
 }