arcane-os 0.57.0 → 0.59.0

package/src/import-map.mjs

@@ -50,6 +50,7 @@ const SDK_BROWSER_SELF_IMPORTS=new Map([
     ['arcane-os/speech-text','sdk/speech-text.mjs'],
     ['arcane-os/ai/browser-wasm',SDK_BROWSER_AI_ENTRY],
     ['arcane-os/ai/core-local','sdk/ai/core-local.mjs'],
+    ['arcane-os/ai/core-onnx','sdk/ai/core-onnx.mjs'],
     ['arcane-os/ai/browser-decisions','sdk/ai/browser-decisions.mjs'],
     ['arcane-os/ai/tool-text-stream','sdk/ai/tool-text-stream.mjs'],
     ['arcane-os/ai/twin-cloud','sdk/ai/twin-cloud.mjs'],
@@ -2090,8 +2091,8 @@ function scanHtmlStructure(html){
     return {scripts,links,bases,metas,elements,styles,headClose,bodyClose};
 }
 
-/** Remove generated PWA references from a selected output document without changing authored content. */
-export function removePwaEntryReferences(html, {documentUrl, manifestUrl} = {}) {
+/** Retire active PWA references; source refresh may restrict removal to marked ownership. */
+export function removePwaEntryReferences(html, {documentUrl, manifestUrl, markedManifestOnly = false} = {}) {
     if (!is.string(html)) throw new TypeError('PWA entry HTML must be a string.');
     const structure = scanHtmlStructure(html);
     const manifest = new URL(manifestUrl, documentUrl);
@@ -2105,6 +2106,7 @@ export function removePwaEntryReferences(html, {documentUrl, manifestUrl} = {})
     const edits = [];
     for (const link of structure.links) {
         const attributes = parseTagAttributes(link.open);
+        if (markedManifestOnly && !attributes.has('data-arcane-manifest')) continue;
         const href = htmlAttributeView(attributes.get('href') ?? '');
         const rel = htmlAttributeView(attributes.get('rel') ?? '');
         if (!href?.decoded || !rel) continue;
@@ -2151,7 +2153,7 @@ export function removePwaEntryReferences(html, {documentUrl, manifestUrl} = {})
 }
 
 /** Update only active PWA entry references; registration never orders application startup. */
-export function applyPwaEntryReferences(html,{manifestUrl,bootstrapUrl}={}){
+export function applyPwaEntryReferences(html,{manifestUrl,bootstrapUrl,markGeneratedManifest=false}={}){
     if(!is.string(html))throw new TypeError('PWA entry HTML must be a string.');
     if(!is.string(manifestUrl)||!manifestUrl||!is.string(bootstrapUrl)||!bootstrapUrl){
         throw new TypeError('PWA manifestUrl and bootstrapUrl must be nonempty strings.');
@@ -2222,7 +2224,10 @@ export function applyPwaEntryReferences(html,{manifestUrl,bootstrapUrl}={}){
             });
         }
     }
-    if(!manifestFound)additions.push(`<link rel="manifest" href="${attributeText(manifestUrl)}">`);
+    if(!manifestFound){
+        const marker=markGeneratedManifest?' data-arcane-manifest':'';
+        additions.push(`<link rel="manifest" href="${attributeText(manifestUrl)}"${marker}>`);
+    }
     let bootstrapFound=false;
     for(const script of structure.scripts){
         if(!parseTagAttributes(script.open).has('data-arcane-pwa'))continue;

package/src/index.mjs

@@ -65,6 +65,7 @@ export {
     TIME_TRAVEL_SEEK_EVENT
 } from './event-manager.mjs';
 export {runProcess} from './process.mjs';
+export {createGitTextSnapshot} from './git-text-snapshot.mjs';
 export {
     DEFAULT_TEST_TIMEOUT_MS,
     registeredTestCount,

package/src/local-ai/config.mjs

@@ -4,7 +4,7 @@ import Is from 'strong-type';
 import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
 
 const is = new Is(false);
-export const LOCAL_AI_RUNTIME_IDS = ['llama.cpp', 'ollama'];
+export const LOCAL_AI_RUNTIME_IDS = ['llama.cpp', 'ollama', 'onnx'];
 
 /** Runtime requirements are application configuration, separate from models. */
 export function normalizeLocalAIConfig(value) {

package/src/local-ai/install.mjs

@@ -1,11 +1,13 @@
 import Is from 'strong-type';
 import {createWriteStream} from 'node:fs';
 import {chmod,copyFile,lstat,mkdir,mkdtemp,readFile,readdir,readlink,rm,stat,symlink,unlink,writeFile} from 'node:fs/promises';
+import {createRequire} from 'node:module';
 import path from 'node:path';
 import {Readable} from 'node:stream';
 import {pipeline} from 'node:stream/promises';
 import {ArcaneError,ERROR_CODES,normalizeError,throwIfAborted} from '../errors.mjs';
 import {createEventQueue} from '../event-queue.mjs';
+import {runProcess} from '../process.mjs';
 import {extractLocalAIArchive} from './archive.mjs';
 
 const is=new Is(false);
@@ -16,8 +18,9 @@ function selectRuntimes(runtimes){
         throw new ArcaneError(ERROR_CODES.usage,'Local AI runtimes must be an array.');
     }
     const selected=new Map();
-    for(const runtime of runtimes){
-        if(!runtime||!['llama.cpp','ollama'].includes(runtime.id)){
+    for(const item of runtimes){
+        const runtime=is.string(item)?{id:item}:item;
+        if(!runtime||!['llama.cpp','ollama','nemo-speech','onnx'].includes(runtime.id)){
             throw new ArcaneError(ERROR_CODES.targetUnavailable,`Local AI runtime installation is unavailable for ${String(runtime?.id)}.`);
         }
         const prior=selected.get(runtime.id);
@@ -43,6 +46,15 @@ function selectedDirectory(directory){
 }
 
 function releaseAssetNames(id,version,platform,architecture){
+    if(id==='nemo-speech'){
+        if(!['x64','arm64'].includes(architecture))return [];
+        const arch=architecture==='x64'?'x86_64':'aarch64';
+        const name=`nemo-speech-${version.replace(/^v/u,'')}`;
+        if(platform==='win32'&&architecture==='x64')return [`${name}-windows-${arch}-cpu.zip`];
+        if(platform==='linux')return [`${name}-linux-${arch}-cpu.tar.gz`];
+        if(platform==='darwin')return [`${name}-macos-${arch}-cpu.tar.gz`];
+        return [];
+    }
     if(id==='ollama'){
         if(platform==='darwin'&&['x64','arm64'].includes(architecture))return ['ollama-darwin.tgz'];
         const arch=architecture==='x64'?'amd64':architecture;
@@ -74,9 +86,10 @@ async function selectRelease(runtime,platform,architecture,signal){
         const name=path.posix.basename(new URL(runtime.url).pathname);
         return {version:runtime.version??'custom',url:runtime.url,name};
     }
-    const repository=runtime.id==='llama.cpp'?'ggml-org/llama.cpp':'ollama/ollama';
-    const selected=runtime.version&&runtime.version!=='latest'
-        ?`tags/${encodeURIComponent(runtime.id==='ollama'&&!runtime.version.startsWith('v')?`v${runtime.version}`:runtime.version)}`
+    const repository=runtime.id==='nemo-speech'?'NVIDIA/NeMo-Speech.cpp':runtime.id==='llama.cpp'?'ggml-org/llama.cpp':'ollama/ollama';
+    const version=runtime.version??(runtime.id==='nemo-speech'?'0.2.0':undefined);
+    const selected=version&&version!=='latest'
+        ?`tags/${encodeURIComponent(runtime.id!=='llama.cpp'&&!version.startsWith('v')?`v${version}`:version)}`
         :'latest';
     let release=await (await upstreamResponse(`https://api.github.com/repos/${repository}/releases/${selected}`,signal)).json();
     if(runtime.id==='llama.cpp'){
@@ -118,8 +131,24 @@ async function installedRuntime(base,runtime,platform,architecture,signal){
         const record=installation.runtime;
         if(record?.id!==runtime.id||record.platform!==platform||record.architecture!==architecture)continue;
         try{
+            if(runtime.id==='onnx'){
+                if(!is.string(record.root)||!is.string(record.modulePath))continue;
+                const locations=await onnxRuntimeModule(record.root,platform,architecture,signal);
+                return {...record,...locations,...(runtime.version?{requestedVersion:runtime.version}:{})};
+            }
+            if(runtime.id==='nemo-speech'){
+                const directories=[record.root,record.includeDirectory,record.libraryDirectory,record.binaryDirectory,record.cmakeDirectory];
+                if(directories.some(function missingDirectory(directory){return !is.string(directory);}))continue;
+                const files=[path.join(record.includeDirectory,'nemo_speech','diar.h'),path.join(record.includeDirectory,'nemo_speech','asr.h'),path.join(record.cmakeDirectory,'NeMoSpeechConfig.cmake')];
+                const entries=await Promise.all([...directories,...files].map(function inspectRuntimePath(location){return stat(location);}));
+                if(entries.every(function runtimePathPresent(info,index){return index<directories.length?info.isDirectory():info.isFile();})){
+                    return {...record,...(runtime.version?{requestedVersion:runtime.version}:{})};
+                }
+                continue;
+            }
             if((await stat(record.executable)).isFile())return {...record,...(runtime.version?{requestedVersion:runtime.version}:{})};
         }catch(error){
+            if(runtime.id==='onnx'&&(error.code==='MODULE_NOT_FOUND'||error instanceof SyntaxError))continue;
             if(error.code!=='ENOENT')throw error;
         }
     }
@@ -141,6 +170,77 @@ async function runtimeExecutable(root,id,platform,signal){
     throw new ArcaneError(ERROR_CODES.operationFailed,`The ${id} archive does not contain ${filename}.`);
 }
 
+async function nemoRuntimeDirectories(root,signal){
+    const directories=[root];
+    for(const directory of directories){
+        throwIfAborted(signal);
+        const entries=await readdir(directory,{withFileTypes:true});
+        for(const entry of entries){
+            if(entry.isDirectory())directories.push(path.join(directory,entry.name));
+        }
+        if(path.basename(directory)!=='nemo_speech'||path.basename(path.dirname(directory))!=='include')continue;
+        const headers=['diar.h','asr.h'];
+        if(!headers.every(function headerPresent(name){
+            return entries.some(function matchingHeader(entry){return entry.name===name&&(entry.isFile()||entry.isSymbolicLink());});
+        }))continue;
+        const includeDirectory=path.dirname(directory);
+        const prefix=path.dirname(includeDirectory);
+        const children=await readdir(prefix,{withFileTypes:true});
+        const binaryDirectory=path.join(prefix,'bin');
+        if(!(await stat(binaryDirectory)).isDirectory()){
+            throw new ArcaneError(ERROR_CODES.operationFailed,'The NeMo Speech archive does not contain its installed binary directory.');
+        }
+        const candidates=children.filter(function libraryDirectory(entry){
+            return ['lib','lib64'].includes(entry.name)&&(entry.isDirectory()||entry.isSymbolicLink());
+        }).map(function librarySearch(entry){
+            const libraryDirectory=path.join(prefix,entry.name);
+            return {directory:libraryDirectory,libraryDirectory};
+        });
+        for(const candidate of candidates){
+            throwIfAborted(signal);
+            const entries=await readdir(candidate.directory,{withFileTypes:true});
+            if(entries.some(function packageConfiguration(entry){
+                return entry.name==='NeMoSpeechConfig.cmake'&&(entry.isFile()||entry.isSymbolicLink());
+            })){
+                return {includeDirectory,libraryDirectory:candidate.libraryDirectory,binaryDirectory,cmakeDirectory:candidate.directory};
+            }
+            for(const entry of entries){
+                if(entry.isDirectory())candidates.push({directory:path.join(candidate.directory,entry.name),libraryDirectory:candidate.libraryDirectory});
+            }
+        }
+        throw new ArcaneError(ERROR_CODES.operationFailed,'The NeMo Speech archive does not contain its installed NeMoSpeech CMake package.');
+    }
+    throw new ArcaneError(ERROR_CODES.operationFailed,'The NeMo Speech archive does not contain include/nemo_speech/diar.h and asr.h.');
+}
+
+async function onnxRuntimeModule(root,platform,architecture,signal){
+    throwIfAborted(signal);
+    const packageDirectory=path.join(root,'node_modules','onnxruntime-node');
+    const metadata=JSON.parse(await readFile(path.join(packageDirectory,'package.json'),{encoding:'utf8',signal}));
+    // Node resolves the installed public entry without loading its native code.
+    const modulePath=createRequire(path.join(root,'package.json')).resolve('onnxruntime-node');
+    const binding=path.join(packageDirectory,'bin','napi-v6',platform,architecture,'onnxruntime_binding.node');
+    const entries=await Promise.all([modulePath,binding].map(function inspectONNXFile(filename){return stat(filename);}));
+    if(!entries.every(function onnxFilePresent(info){return info.isFile();})){
+        throw new ArcaneError(ERROR_CODES.operationFailed,`The ONNX package does not contain its public module and ${platform}/${architecture} native binding.`);
+    }
+    throwIfAborted(signal);
+    return {version:metadata.version,modulePath};
+}
+
+async function installONNXPackage(runtime,{root,directory,platform,architecture,signal,onEvent}){
+    const version=runtime.version??'1.30.0';
+    await onEvent({type:'local-ai.install.installing',message:`Installing onnxruntime-node ${version} for ${platform}/${architecture}.`,data:{id:runtime.id,version,platform,architecture}});
+    await mkdir(root,{recursive:true});
+    await writeFile(path.join(root,'package.json'),'{"private":true}\n',{flag:'wx',signal});
+    await runProcess('npm',[
+        'install','--prefix',root,'--global=false','--save-exact','--omit=dev',
+        '--no-audit','--no-fund','--foreground-scripts','--registry=https://registry.npmjs.org/',
+        '--cache',path.join(directory,'npm-cache'),`onnxruntime-node@${runtime.url??version}`
+    ],{cwd:root,env:{ONNXRUNTIME_NODE_INSTALL:'skip'},signal,onEvent});
+    return onnxRuntimeModule(root,platform,architecture,signal);
+}
+
 async function installRuntime(runtime,{directory,platform,architecture,signal,onEvent}){
     const base=path.join(directory,runtime.id,`${platform}-${architecture}`,encodeURIComponent(runtime.version??'default'));
     await onEvent({type:'local-ai.install.starting',message:`Preparing ${runtime.id} for ${platform}/${architecture}.`,data:{id:runtime.id,platform,architecture}});
@@ -149,26 +249,36 @@ async function installRuntime(runtime,{directory,platform,architecture,signal,on
         await onEvent({type:'local-ai.install.available',message:`${runtime.id} ${installed.version} is already installed.`,data:installed});
         return installed;
     }
-    const release=await selectRelease(runtime,platform,architecture,signal);
+    if(runtime.id==='onnx'&&(!['win32','linux','darwin'].includes(platform)||!['x64','arm64'].includes(architecture))){
+        throw new ArcaneError(ERROR_CODES.targetUnavailable,`onnxruntime-node has no supported ${platform}/${architecture} CPU runtime.`);
+    }
+    const release=runtime.id==='onnx'?null:await selectRelease(runtime,platform,architecture,signal);
     throwIfAborted(signal);
     await mkdir(base,{recursive:true});
     const attempt=await mkdtemp(path.join(base,'install-'));
     const root=path.join(attempt,'runtime');
-    const archive=path.join(attempt,release.name);
+    const archive=release?path.join(attempt,release.name):null;
     let completed=false;
     try{
-        await onEvent({type:'local-ai.install.downloading',message:`Downloading ${runtime.id} ${release.version}.`,data:{id:runtime.id,version:release.version,platform,architecture}});
-        const response=await upstreamResponse(release.url,signal);
-        await pipeline(Readable.fromWeb(response.body),createWriteStream(archive,{flags:'wx'}),{signal});
-        await onEvent({type:'local-ai.install.extracting',message:`Extracting ${runtime.id} ${release.version}.`,data:{id:runtime.id,version:release.version}});
-        await extractLocalAIArchive({archive,directory:root,signal,onEvent});
-        const executable=await runtimeExecutable(root,runtime.id,platform,signal);
-        const record={id:runtime.id,version:release.version,platform,architecture,root,executable,...(runtime.version?{requestedVersion:runtime.version}:{})};
+        let locations;
+        if(runtime.id==='onnx'){
+            locations=await installONNXPackage(runtime,{root,directory,platform,architecture,signal,onEvent});
+        }else{
+            await onEvent({type:'local-ai.install.downloading',message:`Downloading ${runtime.id} ${release.version}.`,data:{id:runtime.id,version:release.version,platform,architecture}});
+            const response=await upstreamResponse(release.url,signal);
+            await pipeline(Readable.fromWeb(response.body),createWriteStream(archive,{flags:'wx'}),{signal});
+            await onEvent({type:'local-ai.install.extracting',message:`Extracting ${runtime.id} ${release.version}.`,data:{id:runtime.id,version:release.version}});
+            await extractLocalAIArchive({archive,directory:root,signal,onEvent});
+            locations={version:release.version,...(runtime.id==='nemo-speech'
+                ?await nemoRuntimeDirectories(root,signal)
+                :{executable:await runtimeExecutable(root,runtime.id,platform,signal)})};
+        }
+        const record={id:runtime.id,platform,architecture,root,...locations,...(runtime.version?{requestedVersion:runtime.version}:{})};
         throwIfAborted(signal);
-        await unlink(archive);
+        if(archive)await unlink(archive);
         await writeFile(path.join(attempt,'installation.json'),`${JSON.stringify({requestVersion:runtime.version??null,requestUrl:runtime.url??null,runtime:record},null,2)}\n`,{flag:'wx',signal});
         completed=true;
-        await onEvent({type:'local-ai.install.completed',message:`${runtime.id} ${release.version} is available.`,data:record});
+        await onEvent({type:'local-ai.install.completed',message:`${runtime.id} ${record.version} is available.`,data:record});
         return record;
     }catch(error){
         // Only this invocation's newly created incomplete attempt is removed.
@@ -272,8 +382,8 @@ export async function ensureLocalAIRuntimes({runtimes=[],directory,platform=proc
     },5000);
     heartbeat.unref?.();
     try{
-        // There is one job per selected runtime, at most one llama.cpp and one
-        // Ollama job. Independent runtimes download and extract concurrently.
+        // There is one job per selected runtime. Independent runtime archives
+        // download and extract concurrently; matching requests share that job.
         const outcomes=await Promise.allSettled(selected.map(function prepareRuntime(runtime){
             return shareInstallation(runtime,{directory:root,platform,architecture,signal:operationSignal,onEvent:events.send});
         }));
@@ -332,7 +442,12 @@ export async function bundleLocalAIRuntimes({runtimes=[],directory,outputRoot,pl
         const relative=`runtime/local-ai/${runtime.id}`;
         const destination=path.join(root,relative);
         await copyRuntimeTree(runtime.root,destination,root,files,signal);
-        return {runtime:{...runtime,root:relative,executable:`${relative}/${path.relative(runtime.root,runtime.executable).split(path.sep).join('/')}`},files};
+        const bundled={...runtime,root:relative};
+        for(const field of ['executable','modulePath','includeDirectory','libraryDirectory','binaryDirectory','cmakeDirectory']){
+            if(runtime[field]===undefined)continue;
+            bundled[field]=path.posix.join(relative,path.relative(runtime.root,runtime[field]).split(path.sep).join('/'));
+        }
+        return {runtime:bundled,files};
     }));
     const failures=outcomes.filter(function failedBundle(outcome){return outcome.status==='rejected';});
     if(failures.length===1)throw failures[0].reason;

package/src/local-ai/onnx-worker.mjs

@@ -0,0 +1,85 @@
+import {parentPort,workerData} from 'node:worker_threads';
+import {pathToFileURL} from 'node:url';
+import Is from 'strong-type';
+
+const is=new Is(false);
+const imported=await import(pathToFileURL(workerData.modulePath).href);
+const ort=imported.default??imported;
+let session;
+
+function describeError(error){
+    if(!(error instanceof Error))return {name:'Error',message:String(error),cause:error};
+    const result={...error,name:error.name,message:error.message,stack:error.stack};
+    if(error.cause!==undefined)result.cause=error.cause instanceof Error?describeError(error.cause):error.cause;
+    if(error instanceof AggregateError)result.errors=error.errors.map(describeError);
+    return result;
+}
+
+function tensorMap(records,inputs=false){
+    return Object.fromEntries(Object.entries(records).map(function createTensor([name,record]){
+        // ORT Node 1.30.0 supplies string feeds to FillStringTensor through
+        // null-terminated strings, so this exact content cannot be preserved.
+        if(inputs&&record?.type==='string'&&is.array(record.data)
+            &&record.data.some(function embeddedNull(value){return is.string(value)&&value.includes('\0');})){
+            const error=new Error(`ONNX Runtime Node cannot preserve embedded U+0000 in string tensor input "${name}".`);
+            error.code='LOCAL_AI_ONNX_STRING_INPUT_UNSUPPORTED';
+            throw error;
+        }
+        return [name,record===null?null:new ort.Tensor(record.type,record.data,record.dims)];
+    }));
+}
+
+async function handleRequest(request){
+    try{
+        let result;
+        if(request.operation==='load'){
+            const supplied=request.sessionOptions;
+            const options=supplied===undefined
+                ?{executionProviders:['cpu']}
+                :supplied!==null&&is.object(supplied)&&supplied.executionProviders===undefined
+                    ?{...supplied,executionProviders:['cpu']}
+                    :supplied;
+            session=await ort.InferenceSession.create(request.model,options);
+            result={
+                inputNames:session.inputNames,
+                outputNames:session.outputNames,
+                inputMetadata:session.inputMetadata,
+                outputMetadata:session.outputMetadata
+            };
+        }else if(request.operation==='run'){
+            const feeds=tensorMap(request.feeds,true);
+            const fetches=request.fetches===undefined||request.fetches===null||is.array(request.fetches)
+                ?request.fetches:tensorMap(request.fetches);
+            // ORT treats an empty fetch map as its options overload and would
+            // ignore the third argument. Both forms select every output.
+            const allOutputs=fetches===undefined
+                ||(fetches!==null&&!is.array(fetches)&&Object.keys(fetches).length===0);
+            const outputs=allOutputs
+                ?await session.run(feeds,request.runOptions)
+                :await session.run(feeds,fetches,request.runOptions);
+            result=Object.fromEntries(Object.entries(outputs).map(function tensorRecord([name,tensor]){
+                return [name,{type:tensor.type,data:tensor.data,dims:tensor.dims}];
+            }));
+        }else if(request.operation==='unload'){
+            await session?.release();
+            session=undefined;
+        }else{
+            throw new Error(`Unknown ONNX worker operation: ${String(request.operation)}.`);
+        }
+        // Structured cloning retains typed tensors and BigInt without taking
+        // ownership of the caller's buffers or converting their contents.
+        parentPort.postMessage({requestId:request.requestId,operation:request.operation,result});
+    }catch(error){
+        parentPort.postMessage({requestId:request.requestId,operation:request.operation,error:describeError(error)});
+    }finally{
+        if(request.operation==='unload')parentPort.close();
+    }
+}
+
+parentPort.on('message',function receiveRequest(request){
+    // The session owner dispatches one operation at a time. Native ORT work
+    // runs synchronously inside this worker, never on the caller's thread.
+    void handleRequest(request).catch(function reportWorkerFailure(error){
+        setImmediate(function throwWorkerFailure(){throw error;});
+    });
+});