arcane-os 0.92.0 → 0.94.0

package/docs/reference/sdk-api.md

@@ -82,6 +82,7 @@ runtime layouts.
 | `arcane-os/core/image` | Native image Core service with independent runtime preparation and retained model ownership. |
 | `arcane-os/core/speech` | Independent injected STT/TTS engine loading, request cancellation and joined Core service lifetime. |
 | `arcane-os/local-ai/whisper` | Retained native Whisper model, complete recordings and joined helper lifetime. |
+| `arcane-os/local-ai/kokoro` | Retained native Kokoro synthesis using the existing ONNX/model-resource owners and a compiled phonemization/Opus helper. |
 | `arcane-os/local-ai/whisper/build` | First-party persistent helper build against selected installed Whisper headers and libraries. |
 | `arcane-os/local-ai/whisper/openvino-build` | Optional Windows x64 Intel NPU encoder runtime producer using selected installed sources and toolchain. |
 | `arcane-os/ai/core-model-assets` | Complete stored browser model members projected through Core into native working files. |
@@ -469,6 +470,12 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | `createLocalImageService()` | function | `arcane-os/core/image` | Core local images | Node Core with selected stable-diffusion.cpp requirements |
 | `createLocalImageService default export` | function | `arcane-os/core/image` | Core local images | Same native image service factory |
 | `createSpeechService()` | function | `arcane-os/core/speech` | Core native speech | Node Core with explicitly supplied speech engines |
+| `createNativeKokoroRuntime()` | function | `arcane-os/local-ai/kokoro` | Core native speech | Node with matching prepared helper/data, selected model resources and an existing ONNX owner |
+| `createNativeKokoroRuntime default export` | function | `arcane-os/local-ai/kokoro` | Core native speech | Same retained native Kokoro factory |
+| `KOKORO_MODEL` | constant | `arcane-os/local-ai/kokoro` | Core native speech | Selected upstream model identifier |
+| `KOKORO_REVISION` | constant | `arcane-os/local-ai/kokoro` | Core native speech | Selected upstream model revision |
+| `KOKORO_SAMPLE_RATE` | constant | `arcane-os/local-ai/kokoro` | Core native speech | Native PCM sample rate |
+| `KOKORO_VOICES` | constant | `arcane-os/local-ai/kokoro` | Core native speech | Complete 28-voice US/GB selection |
 | `createWhisperRuntime()` | function | `arcane-os/local-ai/whisper` | Core native speech | Node with a prepared matching helper, runtime, decoder and selected model |
 | `createWhisperRuntime default export` | function | `arcane-os/local-ai/whisper` | Core native speech | Same retained native engine factory |
 | `buildWhisperHelper()` | function | `arcane-os/local-ai/whisper/build` | Core native speech | Node with installed CMake/C++17 toolchain and matching Whisper source/runtime |
@@ -8842,6 +8849,118 @@ selected model and native engine.
 The default export from `arcane-os/core/image` is the same
 `createLocalImageService` factory and lifecycle described above.
 
+## createNativeKokoroRuntime()
+
+### Overview and signature
+
+The named export from `arcane-os/local-ai/kokoro` composes the selected Kokoro
+FP32 graph with the host's existing native ONNX owner, model-resource owner
+and prepared persistent phonemization/Opus helper. Construction starts no
+native work and acquires no model or runtime.
+
+```javascript
+createNativeKokoroRuntime({
+    onnx, modelAssets, runtime, prepare, modelId = 'kokoro',
+    model = KOKORO_MODEL, revision = KOKORO_REVISION, dtype = 'fp32',
+    paths, assetProjectionId, resourcePaths, sessionOptions,
+    executionPreference = 'gpu', executionTarget, signal, onEvent
+} = {})
+```
+
+Supply the existing `onnx` runtime or a `prepare` callback that provides it.
+`runtime` describes the matching native helper and data. `paths` supplies
+complete prepared graph/tokenizer/voice resources; a completed
+`assetProjectionId` instead retains projected resources through `modelAssets`.
+The selected model/revision/FP32 contract is fixed by this frontend.
+See [native Kokoro](native-speech.md) for exact resource mappings, preparation,
+runtime distribution and model ownership.
+
+### Members and results
+
+- `current()` returns complete model/lifecycle state, execution configuration,
+  current request, queue, progress, error, default voice and supported voices.
+- `subscribe(listener,{replay=true,signal}={})` returns an unsubscribe function
+  and replays current state by default.
+- `load(options={})` activates the selected resources, retaining omitted
+  selections. Explicit projection/resource mapping or execution-target changes
+  join prior native retirement before loading the new activation.
+- `synthesize(request,{signal,onProgress,requestId=null}={})` requires a loaded
+  activation. `request` contains the complete `input` string, optional `model`
+  matching `modelId`, `voice` (default `af_heart`), positive finite `speed`
+  (default `1`) and `responseFormat` (`wav` by default, `opus` or `ogg`).
+  The result is `{audioBase64,contentType,sampleRate,channels,model,voice,speed}`;
+  content type is `audio/wav` or `audio/ogg; codecs=opus`, with mono 24kHz PCM
+  synthesis. The full input is processed in ordered model segments.
+- `unload()` retires the activation and joins owned native work. `close()`
+  permanently closes the engine and releases its state subscriptions.
+
+Queued requests retain order. Cancelling a queued request removes only that
+request. Active cancellation waits for actual helper/session retirement;
+surviving requests resume with the same accepted provider configuration.
+The ONNX owner may need a running native call to return before its worker exits.
+Readiness is lost while that retirement/reload occurs. Errors retain the actual
+engine and cleanup failures; unsupported explicit voices or formats are never
+substituted. No audio is played by this engine.
+
+### Example
+
+```javascript
+import {createNativeKokoroRuntime} from 'arcane-os/local-ai/kokoro';
+
+// The host supplies its existing ONNX owner and already prepared resources.
+async function narrateMoonGoat({onnx, runtime, paths}) {
+    const voice = createNativeKokoroRuntime({
+        onnx, runtime, paths, executionPreference: 'cpu'
+    });
+    try {
+        await voice.load();
+        return await voice.synthesize({
+            input: 'Captain Goat has landed. Guard the moon cheese!',
+            voice: 'af_heart', responseFormat: 'wav'
+        });
+    } finally {
+        await voice.close();
+    }
+}
+```
+
+Changing `voice` to `bf_emma` selects British English. `responseFormat: 'opus'`
+selects Ogg Opus encoding. GPU/physical-device selection uses the existing
+[ONNX execution contract](local-ai.md#physical-execution-targets); an accepted
+provider configuration is separate from observed hardware execution.
+The SDK publishes a Windows x64 helper archive. Other platforms need a matching
+custom helper distribution and supported native ONNX host. Native helper
+production and platform execution evidence remain separate.
+
+## createNativeKokoroRuntime default export
+
+The default export from `arcane-os/local-ai/kokoro` is the same
+`createNativeKokoroRuntime` factory with identical inputs, results and lifetime.
+
+## KOKORO_MODEL
+
+Named string export from `arcane-os/local-ai/kokoro`, with value
+`onnx-community/Kokoro-82M-v1.0-ONNX`. It identifies this frontend's model family
+for matching graph, tokenizer and voice resource selection.
+
+## KOKORO_REVISION
+
+Named string export from `arcane-os/local-ai/kokoro`, with value
+`1939ad2a8e416c0acfeecc08a694d14ef25f2231`. Resource preparation uses this
+upstream revision with `KOKORO_MODEL`.
+
+## KOKORO_SAMPLE_RATE
+
+Named number export from `arcane-os/local-ai/kokoro`, with value `24000`.
+It describes the engine's mono PCM synthesis rate in samples per second.
+
+## KOKORO_VOICES
+
+Named array export from `arcane-os/local-ai/kokoro` containing all 28 supported
+US/GB voice identifiers. The engine uses `af_heart` when the caller omits
+`voice`; an explicit unsupported selection reports an error. Use this complete
+array to populate a native Kokoro voice selector.
+
 ## createWhisperRuntime()
 
 ### Overview
@@ -9018,6 +9137,13 @@ The returned object has `name: 'speech'`, `current`, `subscribe`, `close`,
   Core RPC methods. The context supplies `signal`, `requestId` and `emit`.
   The service publishes synchronous accepted `Thinking` before waiting for
   its role's load, then forwards the engine's complete progress and result.
+- `methods['speech.load'](request,context)` and
+  `methods['speech.unload'](request,context)` route explicit activation to the
+  explicit `role: 'stt' | 'tts'` and forward the remaining activation
+  fields and result through that role's configured engine. A startup load remains owned independently of callers
+  waiting for it. The browser facade exposes `Arcane.speech.load(request,options)`
+  and `unload(request,options)` with `signal`, `onRequest` and no elapsed-time
+  cutoff. See [activation routing](native-speech.md) for selection and errors.
 - `close()` and its `drain()` alias stop acceptance, abort the service lifetime,
   close both engines concurrently and await startup and request work. Repeated
   calls share one promise. `dispose()` also releases event subscriptions.
@@ -9123,7 +9249,8 @@ import createLocalAIService from 'arcane-os/core/local-ai';
 ### Overview
 
 Reuses matching managed runtimes or installs complete selected
-llama.cpp/Ollama/ONNX/image distributions or NeMo libraries in an explicitly supplied directory.
+llama.cpp/Ollama/ONNX/image distributions, NeMo libraries or native Kokoro
+helper/data trees in an explicitly supplied directory.
 
 ### Signature and result
 
@@ -9146,6 +9273,12 @@ trees remain intact while a fresh installation is prepared. See
 Image requirements also accept `backend` and
 `models`; their pinned default runtime, CPU/Metal selection and separate model
 preparation are described in [local image generation](local-image-generation.md).
+`kokoro-native` returns `helperExecutable`, `espeakDataDirectory` and
+`libraryDirectory`. Windows x64 defaults to the helper archive from the
+installed SDK's numeric release; an explicit `url` or `helperRoot` selects a
+complete custom distribution. The data directory is the parent of
+`espeak-ng-data`. Helper preparation loads no Kokoro graph and keeps the
+existing ONNX/model-resource owners separate. See [native speech](native-speech.md).
 Matching concurrent
 installs share their work. Downloads retain runtime libraries and surface
 network/archive failures; cancellation and operation events remain observable.
@@ -9189,6 +9322,10 @@ The corrected Windows x64 ONNX selection retains its
 is relocated with the other runtime paths; bundling introduces no separate
 runtime selection. See [ONNX runtime preparation](local-ai.md#development).
 
+Kokoro bundling retains the complete helper/data tree and relocates
+`helperExecutable`, `espeakDataDirectory` and `libraryDirectory`. Its selected
+ONNX runtime and model resources retain their existing independent ownership.
+
 Image records relocate the complete library, binding and variant paths. Model
 URL descriptors retain their original acquisition metadata for preparation
 after launch. Runtime-contained native model paths become artifact-relative;
@@ -11683,10 +11820,11 @@ the message or response callback payload.
 
 **Node and Browser; Cloud transport.** Uses standard Fetch and cancellation,
 without DOM, browser profiles, user singletons, or storage initialization.
-Import starts no request. HTTP `429` whose message contains `overload`
-(case-insensitive) waits
-`3000` milliseconds and retries the complete request; other HTTP failures
-throw their complete parsed JSON or text bodies. A missing key throws
+Import starts no request. Rejected Fetch and all HTTP `429`/`529` share three
+retries. Quota recovery honors `Retry-After`, otherwise waits `3000`, `6000`,
+or `12000` milliseconds by retry number. Active same-endpoint/credential calls
+share quota cooldown and paced dispatch. Complete error bodies remain unchanged
+on exhaustion; other HTTP failures are not retried. A missing key throws
 `AI_PROVIDER_NOT_CONFIGURED`; a missing model throws `TypeError`. `signal`
 cancellation during transport, body reading, retry waiting,
 or callback settlement prevents successful return and uses
@@ -11836,21 +11974,24 @@ Ordinary TWiN callers use `fetchRequest()` instead.
 ### Signature and result
 
 ```text
-async fetchHTTPResponse(url,options)
+async fetchHTTPResponse(url,options,{onRetry=null}={})
 ```
 
 Returns the successful Fetch `Response` without consuming its body. Both URL
 and Fetch options are caller-supplied; this helper adds no key, model, or
 request envelope. Non-success responses are read completely as JSON when the
-content type contains `application/json`, otherwise as text. Only status 429
-with an overload message repeats after 3000 ms; other error bodies are thrown.
+content type contains `application/json`, otherwise as text. Rejected Fetch
+and all `429`/`529` share three retries with complete terminal errors.
+`429` honors `Retry-After` or exponential delay and coordinates a transient
+same-endpoint/credential cooldown. See [shared request behavior](ai/twin-cloud.md#shared-request-behavior).
 
 ### Availability and normalization
 
 **Node and Browser.** Exported from `arcane-os/ai/twin-cloud` for shared SDK
-integration. `options.signal` cancels Fetch and the overload wait and is checked
+integration. `options.signal` cancels Fetch and recovery/pacing waits and is checked
 after response/error-body reads. Cancellation uses
-`ARCANE_AI_REQUEST_ABORTED`. Overload warnings use the existing shared logger.
+`ARCANE_AI_REQUEST_ABORTED`. Retry warnings use the existing shared logger;
+`onRetry` observes complete waiting/requesting records outside the payload.
 
 ### Example
 
@@ -11870,7 +12011,7 @@ Shared complete JSON-body reader built on `fetchHTTPResponse()`.
 ### Signature and result
 
 ```text
-async fetchJSONResponse(url,options)
+async fetchJSONResponse(url,options,{onRetry=null}={})
 ```
 
 Returns the full parsed JSON value. A successful response whose content type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.92.0",
+  "version": "0.94.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -65,6 +65,8 @@
     "./core/stdio": "./src/core/stdio.mjs",
     "./core/host": "./src/core/host.mjs",
     "./core/app-control": "./src/core/app-control.mjs",
+    "./core/native-diagnostics": "./browser-runtime/core/native-diagnostics.mjs",
+    "./core/native-diagnostics-source": "./src/core-native-diagnostics-source.mjs",
     "./codex/app-server": "./src/codex/app-server.mjs",
     "./mcp/stdio": "./src/mcp/stdio-server.mjs",
     "./core/repositories": "./src/core/repositories.mjs",
@@ -87,6 +89,7 @@
     "./local-ai/decisions": "./src/local-ai/decisions.mjs",
     "./local-ai/image": "./src/local-ai/image-runtime.mjs",
     "./local-ai/whisper": "./src/local-ai/whisper/index.mjs",
+    "./local-ai/kokoro": "./src/local-ai/kokoro/index.mjs",
     "./local-ai/whisper/build": "./src/local-ai/whisper/build.mjs",
     "./local-ai/whisper/openvino-build": "./src/local-ai/whisper/openvino-build.mjs",
     "./integrated-provider": "./src/integrated-provider-loader.mjs",

package/schemas/arcane-app.schema.json

@@ -277,12 +277,12 @@
           "type": "array",
           "items": {
             "oneOf": [
-              { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp", "whisper.cpp"] },
+              { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp", "whisper.cpp", "kokoro-native"] },
               {
                 "type": "object",
                 "required": ["id"],
                 "properties": {
-                  "id": { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp"] },
+                  "id": { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp", "kokoro-native"] },
                   "version": { "type": "string" },
                   "url": { "type": "string" },
                   "backend": { "type": "string", "description": "llama.cpp: auto, cpu or cuda. Image runtimes: auto, metal or cpu." },

package/schemas/arcane-package.schema.json

@@ -156,12 +156,12 @@
           "type": "array",
           "items": {
             "oneOf": [
-              { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp", "whisper.cpp"] },
+              { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp", "whisper.cpp", "kokoro-native"] },
               {
                 "type": "object",
                 "required": ["id"],
                 "properties": {
-                  "id": { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp"] },
+                  "id": { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp", "kokoro-native"] },
                   "version": { "type": "string" },
                   "url": { "type": "string" },
                   "backend": { "type": "string", "description": "llama.cpp: auto, cpu or cuda. Image runtimes: auto, metal or cpu." },

package/src/core/app-control.mjs

@@ -15,6 +15,7 @@ export async function connectAppControl({endpoint, signal, onError = reportAppCo
         endpoint,
         closed: connection.closed,
         status(options) { return client.invoke('app.control.status', {}, options); },
+        diagnostics(parameters = {}, options) { return client.invoke('app.control.diagnostics', parameters, options); },
         inspect(parameters = {}, options) { return client.invoke('app.control.inspect', parameters, options); },
         capture(parameters = {}, options) { return client.invoke('app.control.capture', parameters, options); },
         act(parameters, options) { return client.invoke('app.control.act', parameters, options); },

package/src/core/hosts/windows/ArcaneAppControl.cs

@@ -452,7 +452,7 @@ namespace Arcane.Core.Hosts.Windows
                         try
                         {
                             cancellation.Token.ThrowIfCancellationRequested();
-                            if (method != "app.control.status" && method != "app.control.inspect"
+                            if (method != "app.control.status" && method != "app.control.diagnostics" && method != "app.control.inspect"
                                 && method != "app.control.capture" && method != "app.control.act"
                                 && method != "app.control.key" && method != "app.control.resize")
                                 throw new NotSupportedException("The app does not expose " + method + ".");

package/src/core/hosts/windows/ArcaneHost.cs

@@ -24,6 +24,7 @@ namespace Arcane.Core.Hosts.Windows
         public string Title { get; set; }
         public string IconPath { get; set; }
         public string ClassicClientSource { get; set; }
+        public string NativeDiagnosticsSource { get; set; }
         public string AppControlEndpoint { get; set; }
         public string AppControlSource { get; set; }
         public string CoreExecutable { get; set; }
@@ -102,15 +103,20 @@ namespace Arcane.Core.Hosts.Windows
         private readonly Action<string> onDiagnostic;
         private readonly Action<Exception> onError;
         private readonly WebView2 webView;
+        private readonly ArcaneNativeDiagnostics nativeDiagnostics;
         private readonly object stateLock = new object();
         private readonly Queue<CoreDelivery> pending = new Queue<CoreDelivery>();
         private readonly Dictionary<string, long> requestGenerations = new Dictionary<string, long>();
+        private readonly Dictionary<string, DesktopNotificationRequest> desktopNotificationRequests =
+            new Dictionary<string, DesktopNotificationRequest>();
         private readonly List<Exception> failures = new List<Exception>();
         private readonly List<Task> failureNotifications = new List<Task>();
         private readonly TaskCompletionSource<object> ready = new TaskCompletionSource<object>();
         private readonly TaskCompletionSource<object> initialized = new TaskCompletionSource<object>();
         private readonly TaskCompletionSource<object> completion = new TaskCompletionSource<object>();
         private ArcaneCoreProcess core;
+        private ArcaneNotifications desktopNotifications;
+        private Task desktopNotificationsClosing;
         private ArcaneBridge bridge;
         private ArcaneBridge activeBridge;
         private Task initialization;
@@ -119,6 +125,8 @@ namespace Arcane.Core.Hosts.Windows
         private Task iconLoading;
         private Icon applicationIcon;
         private string injectedScript;
+        private string nativeDiagnosticsScript;
+        private bool nativeDiagnosticsRegistered;
         private Exception transportFailure;
         private long generation;
         private long nextGeneration;
@@ -144,6 +152,7 @@ namespace Arcane.Core.Hosts.Windows
             this.options = options;
             this.onDiagnostic = onDiagnostic;
             this.onError = onError;
+            nativeDiagnostics = new ArcaneNativeDiagnostics(Report);
             ready.Task.ContinueWith(ObserveReportedFailure, TaskContinuationOptions.OnlyOnFaulted);
             completion.Task.ContinueWith(ObserveReportedFailure, TaskContinuationOptions.OnlyOnFaulted);
             Text = options.Title;
@@ -494,6 +503,10 @@ namespace Arcane.Core.Hosts.Windows
                 browser.SetVirtualHostNameToFolderMapping(options.OriginHost, applicationRoot,
                     CoreWebView2HostResourceAccessKind.Allow);
                 InstallDocumentBridge(generation);
+                // Register the diagnostic observer first so failures in the
+                // ordinary client itself use an ingress independent of Core.
+                await InstallNativeDiagnosticsAsync(browser);
+                if (closing) return;
                 // The selected generator uses replayRuntimeState:true. Both RPC
                 // installation and the shared event owner remain SDK-owned.
                 Task scripts = Task.WhenAll(InstallClassicClientAsync(browser), InstallAppControlAsync(browser));
@@ -523,6 +536,15 @@ namespace Arcane.Core.Hosts.Windows
             injectedScript = await browser.AddScriptToExecuteOnDocumentCreatedAsync(options.ClassicClientSource);
         }
 
+        private async Task InstallNativeDiagnosticsAsync(CoreWebView2 browser)
+        {
+            if (String.IsNullOrEmpty(options.NativeDiagnosticsSource)) return;
+            browser.AddHostObjectToScript("arcaneDiagnostics", nativeDiagnostics);
+            nativeDiagnosticsRegistered = true;
+            nativeDiagnosticsScript = await browser.AddScriptToExecuteOnDocumentCreatedAsync(options.NativeDiagnosticsSource);
+            nativeDiagnostics.Installed();
+        }
+
         private void NavigationStarting(object sender, CoreWebView2NavigationStartingEventArgs args)
         {
             if (nextGeneration != 0 && navigationId == args.NavigationId) return;
@@ -561,6 +583,33 @@ namespace Arcane.Core.Hosts.Windows
                 if (documentGeneration != generation || closing)
                     throw new InvalidOperationException("The requesting document is no longer connected.");
                 string method = EnvelopeString(envelope, "method");
+                if (EnvelopeString(envelope, "protocol") == "arcane/1")
+                {
+                    if (requestId != null && (method == "notifications.status" || method == "notifications.show"
+                        || method == "notifications.state" || method == "notifications.close"))
+                    {
+                        DesktopNotificationRequest operation = new DesktopNotificationRequest(documentGeneration);
+                        desktopNotificationRequests.Add(requestId, operation);
+                        operation.Completion = CompleteDesktopNotificationAsync(envelope, requestId, method, operation);
+                        operation.Completion.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
+                        // Bridge acceptance means this host owns the request;
+                        // the correlated response carries its native outcome.
+                        return Task.FromResult<object>(null);
+                    }
+                    if (EnvelopeString(envelope, "type") == "control")
+                    {
+                        string control = EnvelopeString(envelope, "control");
+                        DesktopNotificationRequest selected;
+                        if (control == "request.cancel" && desktopNotificationRequests.TryGetValue(
+                            EnvelopeString(envelope, "requestId") ?? String.Empty, out selected)
+                            && selected.Generation == documentGeneration)
+                        {
+                            selected.Cancellation.Cancel();
+                            return Task.FromResult<object>(null);
+                        }
+                        if (control == "requests.cancelAll") CancelDesktopNotificationRequests(documentGeneration);
+                    }
+                }
                 if (requestId != null && EnvelopeString(envelope, "protocol") == "arcane/1"
                     && (method == "window.setTheme" || method == "window.state" || method == "window.setState"))
                 {
@@ -584,6 +633,115 @@ namespace Arcane.Core.Hosts.Windows
             }
         }
 
+        private async Task CompleteDesktopNotificationAsync(Dictionary<string, object> request,
+            string id, string method, DesktopNotificationRequest operation)
+        {
+            try
+            {
+                Dictionary<string, object> response = new Dictionary<string, object>
+                {
+                    { "protocol", "arcane/1" }, { "type", "response" }, { "id", id }
+                };
+                try
+                {
+                    object value;
+                    Dictionary<string, object> parameters = request.TryGetValue("parameters", out value)
+                        ? value as Dictionary<string, object> : new Dictionary<string, object>();
+                    if (parameters == null) throw new ArgumentException("Supply a notification request object.");
+                    if (desktopNotifications == null)
+                        desktopNotifications = new ArcaneNotifications(options.ApplicationId, options.ProfileDirectory,
+                            options.Title, options.IconPath, DesktopNotificationChanged);
+                    Dictionary<string, object> result = await desktopNotifications.InvokeAsync(
+                        method, parameters, operation.Cancellation.Token).ConfigureAwait(false);
+                    // Cancellation after native submission does not rewrite an
+                    // accepted result. Its record also remains in host state.
+                    response["ok"] = true;
+                    response["result"] = result;
+                }
+                catch (Exception error)
+                {
+                    string code = error.Data["code"] as string;
+                    if (code == null) code = error is OperationCanceledException ? "CANCELLED"
+                        : error is ArgumentException ? "INVALID_ARGUMENT" : "ARCANE_NOTIFICATION_FAILED";
+                    response["ok"] = false;
+                    response["error"] = ArcaneHost.ErrorRecord(error, code);
+                }
+                response["time"] = DateTime.UtcNow.ToString("o");
+                string json = ArcaneHost.Serializer().Serialize(response);
+                lock (stateLock) pending.Enqueue(new CoreDelivery(operation.Generation, json));
+                ScheduleDelivery();
+            }
+            catch (Exception error)
+            {
+                // A bridge-accepted request must receive its response or the
+                // owning transport failure, including serialization failures.
+                CoreFailed(error);
+            }
+            finally
+            {
+                lock (stateLock)
+                {
+                    desktopNotificationRequests.Remove(id);
+                    operation.Cancellation.Dispose();
+                }
+            }
+        }
+
+        private void DesktopNotificationChanged(Dictionary<string, object> record)
+        {
+            string json = ArcaneHost.Serializer().Serialize(new Dictionary<string, object>
+            {
+                { "protocol", "arcane/1" }, { "type", "event" },
+                { "event", "notifications.state" }, { "data", record }, { "time", DateTime.UtcNow.ToString("o") }
+            });
+            lock (stateLock) pending.Enqueue(new CoreDelivery(generation, json));
+            ScheduleDelivery();
+        }
+
+        private void CancelDesktopNotificationRequests(long? documentGeneration)
+        {
+            lock (stateLock)
+            {
+                // Cancellation can settle a queued operation synchronously;
+                // iterate a snapshot while its completion removes correlation.
+                foreach (DesktopNotificationRequest operation in
+                    new List<DesktopNotificationRequest>(desktopNotificationRequests.Values))
+                    if (!documentGeneration.HasValue || operation.Generation == documentGeneration.Value)
+                        operation.Cancellation.Cancel();
+            }
+        }
+
+        private void StopDesktopNotifications()
+        {
+            CancelDesktopNotificationRequests(null);
+            if (desktopNotifications == null || desktopNotificationsClosing != null) return;
+            try { desktopNotificationsClosing = desktopNotifications.CloseAsync(); }
+            catch (Exception error) { Report(error); }
+        }
+
+        private async Task DrainDesktopNotificationsAsync()
+        {
+            List<Task> operations = new List<Task>();
+            lock (stateLock)
+            {
+                foreach (DesktopNotificationRequest operation in desktopNotificationRequests.Values)
+                    operations.Add(operation.Completion);
+            }
+            if (desktopNotificationsClosing != null) operations.Add(desktopNotificationsClosing);
+            Task settled = Task.WhenAll(operations);
+            try { await settled; }
+            catch (Exception error) { ReportTaskFailure(settled, error); }
+        }
+
+        private sealed class DesktopNotificationRequest
+        {
+            internal readonly long Generation;
+            internal readonly CancellationTokenSource Cancellation = new CancellationTokenSource();
+            internal Task Completion;
+
+            internal DesktopNotificationRequest(long generation) { Generation = generation; }
+        }
+
         private async Task LoadApplicationIconAsync()
         {
             if (String.IsNullOrEmpty(options.IconPath)) return;
@@ -762,12 +920,14 @@ namespace Arcane.Core.Hosts.Windows
         private void DocumentConnected(long documentGeneration)
         {
             ArcaneBridge previous;
+            long previousGeneration;
             lock (stateLock)
             {
                 if (closing) return;
                 if (documentGeneration == generation && documentReady) return;
                 if (documentGeneration != registeredGeneration) return;
                 previous = activeBridge;
+                previousGeneration = generation;
                 generation = documentGeneration;
                 activeBridge = bridge;
                 documentReady = true;
@@ -775,6 +935,7 @@ namespace Arcane.Core.Hosts.Windows
             if (previous != null && previous != activeBridge)
             {
                 previous.Stop(new OperationCanceledException("The previous document has navigated away."));
+                CancelDesktopNotificationRequests(previousGeneration);
                 if (transportFailure == null)
                 {
                     try { ObserveSend(core.SendAsync(CancelRendererRequests)); }
@@ -960,6 +1121,7 @@ namespace Arcane.Core.Hosts.Windows
             if (IsDisposed) return;
             if (bridge != null) bridge.Stop(transportFailure);
             if (activeBridge != null) activeBridge.Stop(transportFailure);
+            CancelDesktopNotificationRequests(null);
             NotifyTransportFailure();
             if (core != null) core.CloseAsync();
             ScheduleDelivery();
@@ -1010,10 +1172,12 @@ namespace Arcane.Core.Hosts.Windows
         {
             if (closing) return;
             lock (stateLock) closing = true;
+            nativeDiagnostics.Stop();
             if (!started) initialized.TrySetResult(null);
             if (bridge != null) bridge.Stop(new InvalidOperationException("The application window is closing."));
             if (activeBridge != null) activeBridge.Stop(new InvalidOperationException("The application window is closing."));
             StopAppControl();
+            StopDesktopNotifications();
             WindowStateTransition.ReleasePending(this);
             shutdown = DrainAndCloseAsync();
             shutdown.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
@@ -1042,6 +1206,7 @@ namespace Arcane.Core.Hosts.Windows
                 }
             }
             await DrainAppControlAsync();
+            await DrainDesktopNotificationsAsync();
             // Joining the independent image owner belongs after Core input has
             // closed; image I/O must never delay accepted service work draining.
             if (iconLoading != null)
@@ -1069,6 +1234,8 @@ namespace Arcane.Core.Hosts.Windows
                 if (!browserProcessExited && webView.CoreWebView2 != null)
                 {
                     webView.CoreWebView2.RemoveHostObjectFromScript("arcaneBridge");
+                    if (nativeDiagnosticsRegistered) webView.CoreWebView2.RemoveHostObjectFromScript("arcaneDiagnostics");
+                    if (nativeDiagnosticsScript != null) webView.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(nativeDiagnosticsScript);
                     if (injectedScript != null) webView.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(injectedScript);
                     if (appControlScript != null) webView.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(appControlScript);
                 }

package/src/core/hosts/windows/ArcaneLauncher.cs

@@ -101,6 +101,7 @@ namespace Arcane.Core.Hosts.Windows
                     InitialWindowState = OptionalWindowState(windowOptions),
                     IconPath = String.IsNullOrEmpty(icon) ? null : Path.Combine(directory, icon),
                     ClassicClientSource = File.ReadAllText(Path.Combine(directory, RequiredString(client, "source"))),
+                    NativeDiagnosticsSource = File.ReadAllText(Path.Combine(directory, "arcane-native-diagnostics.js")),
                     AppControlEndpoint = appControl == null ? null : RequiredString(appControl, "endpoint"),
                     AppControlSource = appControl == null ? null : File.ReadAllText(Path.Combine(directory, "arcane-app-control.js")),
                     CoreExecutable = Path.Combine(directory, "runtime", "ArcaneCore.exe"),