arcane-os 0.80.0 → 0.82.0

package/src/core/shared-host.mjs

@@ -1,11 +1,11 @@
 import {spawn} from 'node:child_process';
 import {open} from 'node:fs/promises';
-import {createConnection, createServer} from 'node:net';
+import {createServer} from 'node:net';
 import {randomUUID} from 'node:crypto';
-import {createCoreClient} from '../../browser-runtime/core/client.mjs';
 import {CORE_PROTOCOL, CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
 import {createCoreRuntime} from './runtime.mjs';
 import {createCoreFrameDecoder, encodeCoreFrame} from './stdio.mjs';
+import {connectCoreSocket, createCoreSocketConnection, writeCoreSocket as write} from './socket-connection.mjs';
 
 function failure(code, message) { return new CoreError({code, message}); }
 function reportError(error) { console.error('Shared Arcane Core failed:', error); }
@@ -23,29 +23,6 @@ function response(id, result, error) {
         time: new Date().toISOString()};
 }
 
-// A stream write owns terminal events as well as its callback. Some destroyed
-// streams never deliver that callback; retirement must still settle the write.
-function write(output, content) {
-    return new Promise(function writeFrame(resolve, reject) {
-        let settled = false;
-        function finish(error) {
-            if (settled) return;
-            settled = true;
-            output.off('error', finish);
-            output.off('close', closed);
-            output.off('finish', closed);
-            if (error) reject(error);
-            else resolve();
-        }
-        function closed() { finish(failure('CORE_CONNECTION_CLOSED', 'The Core output closed during a write.')); }
-        output.once('error', finish);
-        output.once('close', closed);
-        output.once('finish', closed);
-        if (output.destroyed || output.writableEnded) { closed(); return; }
-        try { output.write(content, finish); } catch (error) { finish(error); }
-    });
-}
-
 /** Claim one app-selected pipe/socket before importing or creating services. */
 export async function startSharedCoreHost({
     endpoint, application, version, configure, getReplayEvents, signal, onError = reportError
@@ -268,29 +245,7 @@ export async function startSharedCoreHost({
 }
 
 function connectSocket(endpoint, signal) {
-    signal?.throwIfAborted();
-    if (typeof endpoint !== 'string' || !endpoint) throw new TypeError('A shared Core endpoint must be a nonempty local pipe/socket path.');
-    return new Promise(function connect(resolve, reject) {
-        const socket = createConnection({path: endpoint});
-        socket.pause();
-        function cleanup() {
-            signal?.removeEventListener('abort', abort);
-            socket.off('connect', connected);
-            socket.off('error', failed);
-        }
-        function failed(error) {
-            cleanup();
-            socket.on('error', reportError);
-            socket.destroy();
-            reject(error);
-        }
-        function abort() { failed(signal.reason); }
-        function connected() { cleanup(); resolve(socket); }
-        socket.once('connect', connected);
-        socket.once('error', failed);
-        signal?.addEventListener('abort', abort, {once: true});
-        if (signal?.aborted) abort();
-    });
+    return connectCoreSocket(endpoint, signal, reportError);
 }
 
 // The child retains its own listener and complete diagnostic file after the
@@ -354,49 +309,10 @@ function launchSelection(start) {
 /** Connect/reuse, optionally starting an explicit independent headless entry. */
 export async function connectSharedCoreHost({endpoint, start, signal, onError = reportError} = {}) {
     const socket = await discover({endpoint, start: launchSelection(start), signal});
-    let client;
-    let receive;
-    let closing = false;
-    let writes = Promise.resolve();
-    let resolveClosed;
-    let rejectClosed;
-    const closed = new Promise(function ownConnection(resolve, reject) { resolveClosed = resolve; rejectClosed = reject; });
-    closed.catch(function observeConnectionFailure() {});
-    function diagnostic(error) { report(onError, error); }
-    function failed(error) { client?.failTransport(error); socket.destroy(); rejectClosed(error); }
-    const decoder = createCoreFrameDecoder(function frame(value) { receive(value); });
-    socket.on('data', function data(chunk) { try { decoder.push(chunk); } catch (error) { failed(error); } });
-    socket.on('error', failed);
-    socket.on('end', function ended() {
-        try { decoder.finish(); } catch (error) { failed(error); }
-    });
-    socket.on('close', function disconnected() {
-        signal?.removeEventListener('abort', abort);
-        if (!closing) client?.failTransport(failure('CORE_CONNECTION_CLOSED', 'The shared Core connection closed.'));
-        resolveClosed();
-    });
-    const transport = {
-        name: 'shared-core',
-        subscribe(listener) {
-            receive = listener;
-            return function disconnect() {
-                closing = true;
-                writes.finally(function retireSocket() { socket.end(); }).catch(diagnostic);
-            };
-        },
-        send(frame) {
-            const content = encodeCoreFrame(frame);
-            writes = writes.then(function sendFrame() { return write(socket, content); });
-            writes.catch(failed);
-            return writes;
-        }
-    };
-    client = createCoreClient({transport, replayRuntimeState: true, onError: diagnostic});
-    function abort() { client.close(); }
-    signal?.addEventListener('abort', abort, {once: true});
-    if (signal?.aborted) abort();
-    socket.resume();
-    return {client, endpoint, closed, close: function close() { client.close(); return closed; },
+    const connection = createCoreSocketConnection({socket, endpoint, signal, onError,
+        replayRuntimeState: true, name: 'shared-core', closedMessage: 'The shared Core connection closed.'});
+    const {client, closed} = connection;
+    return {...connection,
         async shutdown(options) {
             const result = await client.invoke('core.host.shutdown', {}, options);
             client.close();

package/src/core/socket-connection.mjs

@@ -0,0 +1,109 @@
+import {createConnection} from 'node:net';
+import {createCoreClient} from '../../browser-runtime/core/client.mjs';
+import {CoreError} from '../../browser-runtime/core/contracts.mjs';
+import {createCoreFrameDecoder, encodeCoreFrame} from './stdio.mjs';
+
+function failure(code, message) { return new CoreError({code, message}); }
+function reportSocketError(error) { console.error('Arcane Core connection failed:', error); }
+function report(observer, error) {
+    try {
+        Promise.resolve(observer(error)).catch(function observerFailed(cause) { console.error(cause, error); });
+    } catch (cause) { console.error(cause, error); }
+}
+
+// Terminal events settle writes even when a destroyed stream omits its callback.
+export function writeCoreSocket(output, content) {
+    return new Promise(function writeFrame(resolve, reject) {
+        let settled = false;
+        function finish(error) {
+            if (settled) return;
+            settled = true;
+            output.off('error', finish);
+            output.off('close', closed);
+            output.off('finish', closed);
+            if (error) reject(error);
+            else resolve();
+        }
+        function closed() { finish(failure('CORE_CONNECTION_CLOSED', 'The Core output closed during a write.')); }
+        output.once('error', finish);
+        output.once('close', closed);
+        output.once('finish', closed);
+        if (output.destroyed || output.writableEnded) { closed(); return; }
+        try { output.write(content, finish); } catch (error) { finish(error); }
+    });
+}
+
+/** Connect once and pause incoming frames until their owner is attached. */
+export function connectCoreSocket(endpoint, signal, onError = reportSocketError) {
+    signal?.throwIfAborted();
+    if (typeof endpoint !== 'string' || !endpoint) throw new TypeError('A shared Core endpoint must be a nonempty local pipe/socket path.');
+    return new Promise(function connect(resolve, reject) {
+        const socket = createConnection({path: endpoint});
+        socket.pause();
+        function cleanup() {
+            signal?.removeEventListener('abort', abort);
+            socket.off('connect', connected);
+            socket.off('error', failed);
+        }
+        function failed(error) {
+            cleanup();
+            socket.on('error', function connectionFailed(error) { report(onError, error); });
+            socket.destroy();
+            reject(error);
+        }
+        function abort() { failed(signal.reason); }
+        function connected() { cleanup(); resolve(socket); }
+        socket.once('connect', connected);
+        socket.once('error', failed);
+        signal?.addEventListener('abort', abort, {once: true});
+        if (signal?.aborted) abort();
+    });
+}
+
+/** Own one connected socket; the caller decides which RPC methods to expose. */
+export function createCoreSocketConnection({socket, endpoint, signal, onError = reportSocketError,
+    replayRuntimeState = false, name = 'core', closedMessage = 'The Core connection closed.'}) {
+    let client;
+    let receive;
+    let closing = false;
+    let writes = Promise.resolve();
+    let resolveClosed;
+    let rejectClosed;
+    const closed = new Promise(function ownConnection(resolve, reject) { resolveClosed = resolve; rejectClosed = reject; });
+    closed.catch(function observeConnectionFailure() {});
+    function diagnostic(error) { report(onError, error); }
+    function failed(error) { client?.failTransport(error); socket.destroy(); rejectClosed(error); }
+    const decoder = createCoreFrameDecoder(function frame(value) { receive(value); });
+    socket.on('data', function data(chunk) { try { decoder.push(chunk); } catch (error) { failed(error); } });
+    socket.on('error', failed);
+    socket.on('end', function ended() {
+        try { decoder.finish(); } catch (error) { failed(error); }
+    });
+    socket.on('close', function disconnected() {
+        signal?.removeEventListener('abort', abort);
+        if (!closing) client?.failTransport(failure('CORE_CONNECTION_CLOSED', closedMessage));
+        resolveClosed();
+    });
+    const transport = {
+        name,
+        subscribe(listener) {
+            receive = listener;
+            return function disconnect() {
+                closing = true;
+                writes.finally(function retireSocket() { socket.end(); }).catch(diagnostic);
+            };
+        },
+        send(frame) {
+            const content = encodeCoreFrame(frame);
+            writes = writes.then(function sendFrame() { return writeCoreSocket(socket, content); });
+            writes.catch(failed);
+            return writes;
+        }
+    };
+    client = createCoreClient({transport, replayRuntimeState, onError: diagnostic});
+    function abort() { client.close(); }
+    signal?.addEventListener('abort', abort, {once: true});
+    if (signal?.aborted) abort();
+    socket.resume();
+    return {client, endpoint, closed, close: function close() { client.close(); return closed; }};
+}

package/src/local-ai/decision-tokenizer-worker.mjs

@@ -17,7 +17,7 @@ try {
     };
     parentPort.on('message', function encodeRequest({id, rows}) {
         try {
-            const {encoded, pad} = encodeDecisionRows(interfaceAdapter, rows, 'laya');
+            const {encoded, pad} = encodeDecisionRows(interfaceAdapter, rows, workerData.family);
             const inputs = createDecisionInputs(encoded, pad);
             parentPort.postMessage({id, result: inputs});
         } catch (error) {

package/src/local-ai/decision-tokenizer.mjs

@@ -6,7 +6,7 @@ function cancelled() {
 }
 
 /** One tokenizer worker owned by one native model activation. */
-export function createDecisionTokenizer({tokenizerPath, tokenizerConfigPath, signal, onError}) {
+export function createDecisionTokenizer({family = 'laya', tokenizerPath, tokenizerConfigPath, signal, onError}) {
     signal?.throwIfAborted();
     const pending = new Map();
     let nextId = 0;
@@ -14,7 +14,7 @@ export function createDecisionTokenizer({tokenizerPath, tokenizerConfigPath, sig
     let terminalError;
     let exited = false;
     const worker = new Worker(new URL('./decision-tokenizer-worker.mjs', import.meta.url), {
-        workerData: {tokenizerPath, tokenizerConfigPath}
+        workerData: {family, tokenizerPath, tokenizerConfigPath}
     });
     let resolveExit;
     const exit = new Promise(function tokenizerExit(resolve) { resolveExit = resolve; });

package/src/local-ai/decisions.mjs

@@ -5,7 +5,13 @@ import {decodeDecisionOutputs} from '../../browser-runtime/ai/decision-runtime.m
 import {createDecisionTokenizer} from './decision-tokenizer.mjs';
 
 const STATE_EVENT = 'ai.decisions.state';
-const LAYA_FILES = ['onnx/model.onnx', 'onnx/model.onnx_data', 'tokenizer.json', 'tokenizer_config.json'];
+
+function selectedGraph(family, dtype) {
+    if (family === 'laya' && dtype === 'fp32') return 'onnx/model.onnx';
+    if (family === 'laya' && dtype === 'fp16') return 'onnx/model_fp16.onnx';
+    if (family === 'julia' && dtype === 'fp32') return 'model.onnx';
+    throw new TypeError('Native decisions support Laya fp32/fp16 and Julia fp32 graph selections.');
+}
 
 function cancellation(message) {
     return new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message});
@@ -18,6 +24,7 @@ function sameExecutionTarget(left, right) {
 }
 
 function sameActivation(left, right) {
+    if (left.family !== right.family || left.model !== right.model || left.revision !== right.revision || left.dtype !== right.dtype) return false;
     if (!sameExecutionTarget(left.executionTarget, right.executionTarget) || left.assetProjectionId !== right.assetProjectionId) return false;
     if (left.resourcePaths === right.resourcePaths) return true;
     if (!left.resourcePaths || !right.resourcePaths) return false;
@@ -27,15 +34,15 @@ function sameActivation(left, right) {
 }
 
 /**
- * One explicitly activated Laya FP32 model using an existing native ONNX owner.
+ * One explicitly activated typed-decision model using an existing native ONNX owner.
  * It does not create another inference runtime or load on construction.
  */
 export function createNativeDecisionModel({
     onnx, modelAssets, workingDirectory, paths, assetProjectionId, resourcePaths,
-    model = 'onnx-community/laya-typed-decisions-ONNX', revision = 'main',
+    family = 'laya', model = 'onnx-community/laya-typed-decisions-ONNX', revision = 'main',
     dtype = 'fp32', sessionOptions, executionPreference = 'gpu', executionTarget, signal
 } = {}) {
-    if (dtype !== 'fp32') throw new TypeError('This native Laya graph selection requires dtype fp32.');
+    selectedGraph(family, dtype);
     const owner = {};
     const events = createArcaneEventSource(owner, {source: 'native-decisions', eventTypes: [STATE_EVENT]});
     const loads = new Set();
@@ -49,15 +56,17 @@ export function createNativeDecisionModel({
     let lastError = null;
     let execution = null;
     let selectedActivation = {
-        executionTarget,
+        family, model, revision, dtype, executionTarget,
         ...(assetProjectionId == null ? {} : {assetProjectionId, resourcePaths: resourcePaths && {...resourcePaths}})
     };
+    let activeSelection = selectedActivation;
     let pendingActivation;
 
     function current() {
         const pending = pendingActivation && (state !== 'ready' || pendingActivation.entry !== activation) ? pendingActivation : null;
         return {
-            family: 'laya', model, revision, dtype, state,
+            family: activeSelection.family, model: activeSelection.model,
+            revision: activeSelection.revision, dtype: activeSelection.dtype, state,
             loaded: state === 'ready', busy: state === 'loading' || Boolean(pending) || Boolean(activation?.jobs.size),
             activeRequests: activation?.jobs.size ?? 0, progress,
             error: lastError ? serializeCoreError(lastError) : null,
@@ -163,10 +172,14 @@ export function createNativeDecisionModel({
         }
         if (paths) return paths;
         if (!modelAssets) throw new CoreError({code: 'ARCANE_DECISION_ASSETS_UNAVAILABLE', message: 'Native decisions need prepared paths or the Core model-assets owner.'});
-        const base = `https://huggingface.co/${model}/resolve/${encodeURIComponent(revision)}/`;
+        const {family: selectedFamily, model: selectedModel, revision: selectedRevision, dtype: selectedDtype} = entry.selection;
+        const graph = selectedGraph(selectedFamily, selectedDtype);
+        const companion = selectedFamily === 'laya' ? `${graph}_data` : `${graph}.data`;
+        const members = [graph, companion, 'tokenizer.json', 'tokenizer_config.json'];
+        const base = `https://huggingface.co/${selectedModel}/resolve/${encodeURIComponent(selectedRevision)}/`;
         const projection = await modelAssets.prepare({
             id: entry.id, workingDirectory,
-            members: LAYA_FILES.map(function selectFile(path) { return {path, url: new URL(path, base).href}; }),
+            members: members.map(function selectFile(path) { return {path, url: new URL(path, base).href}; }),
             signal: entry.controller.signal,
             onProgress(value) { updateProgress(entry, value); }
         });
@@ -176,7 +189,7 @@ export function createNativeDecisionModel({
         await modelAssets.release(entry.id);
         entry.prepared = false;
         const files = Object.fromEntries(projection.members.map(function memberFile(member) { return [member.path, member.nativePath]; }));
-        return {model: files['onnx/model.onnx'], tokenizer: files['tokenizer.json'], tokenizerConfig: files['tokenizer_config.json']};
+        return {model: files[graph], tokenizer: files['tokenizer.json'], tokenizerConfig: files['tokenizer_config.json']};
     }
 
     function beginActivation(request) {
@@ -187,6 +200,7 @@ export function createNativeDecisionModel({
         request.retained = undefined;
         request.entry = entry;
         activation = entry;
+        activeSelection = entry.selection;
         state = 'loading';
         progress = {phase: 'preparing-model'};
         lastError = null;
@@ -196,6 +210,7 @@ export function createNativeDecisionModel({
             entry.controller.signal.throwIfAborted();
             updateProgress(entry, {phase: 'loading-model'});
             entry.tokenizer = createDecisionTokenizer({
+                family: entry.selection.family,
                 tokenizerPath: files.tokenizer, tokenizerConfigPath: files.tokenizerConfig,
                 signal: entry.controller.signal,
                 onError(error) {
@@ -258,14 +273,22 @@ export function createNativeDecisionModel({
         }).finally(function detachLoadCaller() { operationSignal?.removeEventListener('abort', abort); });
     }
 
-    async function load({signal: operationSignal, executionTarget: requestedTarget, assetProjectionId: requestedProjection, resourcePaths: requestedPaths} = {}) {
+    async function load({
+        family: requestedFamily, model: requestedModel, revision: requestedRevision, dtype: requestedDtype,
+        signal: operationSignal, executionTarget: requestedTarget, assetProjectionId: requestedProjection, resourcePaths: requestedPaths
+    } = {}) {
         assertOpen(operationSignal);
         const projection = requestedProjection === undefined ? selectedActivation.assetProjectionId : requestedProjection;
         const mapping = requestedPaths === undefined ? selectedActivation.resourcePaths : requestedPaths;
         const selection = {
+            family: requestedFamily === undefined ? selectedActivation.family : requestedFamily,
+            model: requestedModel === undefined ? selectedActivation.model : requestedModel,
+            revision: requestedRevision === undefined ? selectedActivation.revision : requestedRevision,
+            dtype: requestedDtype === undefined ? selectedActivation.dtype : requestedDtype,
             executionTarget: requestedTarget === undefined ? selectedActivation.executionTarget : requestedTarget,
             ...(projection == null ? {} : {assetProjectionId: projection, resourcePaths: mapping && typeof mapping === 'object' && !Array.isArray(mapping) ? {...mapping} : mapping})
         };
+        selectedGraph(selection.family, selection.dtype);
         if (pendingActivation && !pendingActivation.controller.signal.aborted && sameActivation(pendingActivation.selection, selection)) {
             return observeLoad(pendingActivation, operationSignal);
         }