arcane-os 0.66.0 → 0.68.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 0.68.0
+
+- Add per-instance theme-switcher `configure({modes,labels})` and initial
+  `data-modes` / `data-system-label` presentation. Applications can select
+  Light / Dark / System with complete readable labels while the default
+  Auto / Light / Dark / Skin choices remain unchanged. Preserve selected,
+  disabled and keyboard-focus states with wrapping based on component space.
+- Distinguish a wholly absent Core namespace from a missing method in a
+  registered service. Retain `METHOD_NOT_ALLOWED` and add exact `method`,
+  `namespace` and `reason` lookup metadata; genuine handler errors remain intact.
+- Let the default preference adapter complete single operations through its
+  existing app-scoped local store only after an exact absent preferences
+  namespace response, retaining cancellation, disposal and full values.
+  An advertised rejected atomic batch is never retried as serial writes.
+- Treat an exactly absent optional appearance namespace as unsupported, keeping
+  the original diagnostic. Preserve partial-service and genuine errors, the
+  existing theme persistence order, native window theming and app-owned host
+  preferences. No OS-wide appearance change, migration or dependency is added.
+
+## 0.67.0
+
+- Add native Laya FP32 typed decisions through `arcane-os/local-ai/decisions`
+  and `arcane-os/core/decisions`, using the existing native ONNX and model-assets
+  owners plus the approved `@huggingface/tokenizers@0.2.0` Worker dependency.
+  Explicit activation preserves complete rows, graph outputs, ordered results,
+  current-state replay, cancellation and actual worker-exit file lifetime.
+- Compose selected native services through one Core owner, prepare complete
+  model files through the existing asset owner, and expose actual GPU-provider
+  attempts with CPU fallback. Accepted configuration does not prove GPU execution.
+- Follow late Core client installation and retirement in default AI accessors.
+  Keep explicit clients fixed, model observation non-loading and disposal tied
+  to actual retained ownership. Preserve recoverable native inference errors
+  without retiring a healthy session or cancelling sibling work; terminal
+  stopping revokes readiness while resources remain retained until actual exit.
+- Add repository `configuration()` observations and captured `target:{remote,ref}`
+  options for ordinary fast-forward pull, non-force push and write. Preserve
+  complete configuration values, payloads and failures without switching branches,
+  rewriting Git configuration or changing omitted-target behavior.
+- Keep theme controls, shared same-app host discovery and optional NPU asset
+  transport follow-through separate. No app data migration or automatic model
+  activation is introduced; applications own their selections and orchestration.
+
 ## 0.66.0
 
 - Add `readGitIdentity` from `arcane-os/core/repositories` for separate global,

package/README.md

@@ -20,7 +20,7 @@ selected SDK projection or an explicit live SDK source mount. Both profiles
 share the theme, packaging, event, cancellation,
 and browser run contracts while retaining their selected application layout.
 
-This checkout defines the `0.66.0` SDK contract. Development applications declare
+This checkout defines the `0.68.0` SDK contract. Development applications declare
 `arcane-os` as `latest` and retain their lockfile. Exact SDK pins begin when Roshi
 designates a production build. Follow [Consumer updates](docs/consumer-updates.md)
 to refresh and compare the installed SDK and lockfile with the published channel;

package/browser-runtime/ai/core-image.mjs

@@ -1,5 +1,5 @@
 import Is from '../dependencies/strong-type/index.js';
-import {getInstalledCoreClient} from '../core/client.mjs';
+import {subscribeCoreClient} from '../core/client.mjs';
 import {CoreError, serializeCoreError} from '../core/contracts.mjs';
 import {createArcaneEventSource} from '../event-manager.mjs';
 
@@ -50,7 +50,7 @@ async function encodeImage(image, signal) {
 
 /** Browser access to the selected native image service; no result persistence. */
 export function createCoreImageRuntime(
-    {client = getInstalledCoreClient(), signal, onEvent} = {}
+    {client: suppliedClient, signal, onEvent} = {}
 ) {
     const owner = {};
     const events = createArcaneEventSource(
@@ -60,26 +60,37 @@ export function createCoreImageRuntime(
     const lifetime = new AbortController();
     const lifetimeSignal = signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal;
     const pending = new Set();
-    let state = {
-        id: 'stable-diffusion.cpp',
-        installed: false,
-        available: false,
-        selectedModel: null,
-        loaded: false,
-        state: client ? 'unknown' : 'unavailable',
-        backend: null,
-        devices: [],
-        resources: {},
-        progress: null,
-        error: null,
-        models: []
-    };
+    let client = null;
+    let connection = null;
+    let stopInstallation;
+    let state = emptyState();
     let revision = 0;
     let closed = false;
     let closing;
 
+    function emptyState(error = null) {
+        return {
+            id: 'stable-diffusion.cpp',
+            installed: false,
+            available: false,
+            selectedModel: null,
+            loaded: false,
+            state: client ? 'unknown' : 'unavailable',
+            backend: null,
+            devices: [],
+            resources: {},
+            progress: null,
+            error: error ? serializeCoreError(error) : null,
+            models: []
+        };
+    }
+
     function current() {
-        const requests = [...pending].map(
+        const requests = [...pending].filter(
+            function currentConnectionRequest(request) {
+                return request.connection === connection && !request.signal.aborted;
+            }
+        ).map(
             function requestState(request) {
                 return {
                     method: request.method,
@@ -97,7 +108,7 @@ export function createCoreImageRuntime(
                     return request.status === 'Thinking';
                 }
             ) ? 'Thinking' : null,
-            busy: pending.size > 0,
+            busy: requests.length > 0,
             closed
         };
     }
@@ -146,8 +157,38 @@ export function createCoreImageRuntime(
         publish();
     }
 
-    const unsubscribe = client?.events.on('image.state', accept)
-        ?? function noCoreSubscription() {};
+    function bindClient({client: nextClient, error = null}) {
+        if (closed || (connection && nextClient === client)) {
+            return;
+        }
+        const previous = connection;
+        client = nextClient;
+        const currentConnection = {client, controller: new AbortController(), unsubscribe: null};
+        connection = currentConnection;
+        revision += 1;
+        state = emptyState(error);
+        previous?.unsubscribe?.();
+        previous?.controller.abort();
+        if (client) {
+            currentConnection.unsubscribe = client.events.on(
+                'image.state',
+                function currentImageState(value) {
+                    if (connection === currentConnection) accept(value);
+                }
+            );
+        }
+        publish();
+        if (!closed && connection === currentConnection && client) {
+            // Observe only; installation never loads an engine or model.
+            inspect().catch(
+                function initialImageStateUnavailable(error) {
+                    if (!closed && connection === currentConnection && !currentConnection.controller.signal.aborted) {
+                        reportObserverFailure(error);
+                    }
+                }
+            );
+        }
+    }
 
     function invoke(method, parameters, {signal: requestSignal, onProgress} = {}) {
         if (closed) {
@@ -156,11 +197,15 @@ export function createCoreImageRuntime(
         if (!client) {
             throw unavailable('Local image generation requires an available Core connection.');
         }
-        const operationSignal = requestSignal
-            ? AbortSignal.any([requestSignal, lifetimeSignal]) : lifetimeSignal;
+        const currentConnection = connection;
+        const operationSignal = AbortSignal.any(
+            [lifetimeSignal, currentConnection.controller.signal, ...(requestSignal ? [requestSignal] : [])]
+        );
         operationSignal.throwIfAborted();
         const request = {
             method,
+            connection: currentConnection,
+            signal: operationSignal,
             revision,
             streamId: parameters.streamId,
             status: method === 'image.generate' || method === 'image.edit' ? 'Thinking' : null,
@@ -169,7 +214,7 @@ export function createCoreImageRuntime(
         };
         let stopProgress;
         if (request.streamId) {
-            stopProgress = client.events.on(
+            stopProgress = currentConnection.client.events.on(
                 'image.progress',
                 function imageProgress(value) {
                     if (closed || operationSignal.aborted || value.streamId !== request.streamId) {
@@ -202,7 +247,7 @@ export function createCoreImageRuntime(
                     {type: 'image.request', data: {method, parameters: requestParameters}}
                 );
                 operationSignal.throwIfAborted();
-                const result = await client.invoke(
+                const result = await currentConnection.client.invoke(
                     method,
                     requestParameters,
                     {signal: operationSignal, timeoutMs: 0}
@@ -238,7 +283,7 @@ export function createCoreImageRuntime(
             function releaseImageRequest() {
                 stopProgress?.();
                 pending.delete(request);
-                if (!closed) {
+                if (!closed && connection === currentConnection) {
                     publish();
                 }
             }
@@ -251,12 +296,14 @@ export function createCoreImageRuntime(
 
     async function inspect({signal: requestSignal} = {}) {
         const before = revision;
+        const currentConnection = connection;
         try {
             const result = await invoke(
                 'image.status',
                 {},
                 {signal: requestSignal}
             );
+            currentConnection.controller.signal.throwIfAborted();
             if (!closed && revision === before) {
                 accept(result);
             }
@@ -273,11 +320,13 @@ export function createCoreImageRuntime(
 
     async function load({model, context, assetProjectionId, resourcePaths, signal: requestSignal} = {}) {
         const before = revision;
+        const currentConnection = connection;
         const result = await invoke(
             'image.load',
             {model, context, assetProjectionId, resourcePaths},
             {signal: requestSignal}
         );
+        currentConnection.controller.signal.throwIfAborted();
         if (!closed && revision === before) {
             accept(result);
         }
@@ -308,11 +357,13 @@ export function createCoreImageRuntime(
 
     async function unload({signal: requestSignal} = {}) {
         const before = revision;
+        const currentConnection = connection;
         const result = await invoke(
             'image.unload',
             {},
             {signal: requestSignal}
         );
+        currentConnection.controller.signal.throwIfAborted();
         if (!closed && revision === before) {
             accept(result);
         }
@@ -365,8 +416,10 @@ export function createCoreImageRuntime(
         );
         lifetime.abort();
         lifetimeSignal.removeEventListener('abort', close);
-        unsubscribe();
-        state = {...state, available: false, state: 'closed'};
+        stopInstallation?.();
+        connection?.unsubscribe?.();
+        connection?.controller.abort();
+        state = {...state, available: false, loaded: false, state: 'closed'};
         publish();
         events.dispose();
         return closing;
@@ -379,13 +432,10 @@ export function createCoreImageRuntime(
     );
     if (lifetimeSignal.aborted) {
         close();
-    } else if (client) {
-        // Subscribe before the snapshot request so a later lifecycle event wins.
-        inspect().catch(
-            function initialImageStateUnavailable(error) {
-                globalThis.console?.error('Core image initial state unavailable.', error);
-            }
-        );
+    } else if (suppliedClient === undefined) {
+        stopInstallation = subscribeCoreClient(bindClient, {signal: lifetimeSignal});
+    } else {
+        bindClient({client: suppliedClient});
     }
 
     return {load, generate, edit, unload, inspect, current, subscribe, close};