arcane-os 0.93.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.93.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",
@@ -89,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/services/speech.mjs

@@ -44,8 +44,8 @@ function waitForLoad(task, signal) {
 /** Hosts supply selected engines; this service owns their independent lifetimes. */
 export function createSpeechService({stt, tts, signal} = {}) {
     const roles = {
-        stt: {engine: stt, operation: 'transcribe', state: null, loading: null, unsubscribe: null},
-        tts: {engine: tts, operation: 'synthesize', state: null, loading: null, unsubscribe: null}
+        stt: {engine: stt, operation: 'transcribe', state: null, loading: null, changing: null, unsubscribe: null},
+        tts: {engine: tts, operation: 'synthesize', state: null, loading: null, changing: null, unsubscribe: null}
     };
     for (const [name, role] of Object.entries(roles)) {
         if (role.engine == null) {
@@ -124,6 +124,36 @@ export function createSpeechService({stt, tts, signal} = {}) {
         publish();
     }
 
+    function observeRoleTask(name, task, startup = false) {
+        const role = roles[name];
+        role.changing = task;
+        // Explicit load cancellation belongs to that caller's wait, not another
+        // inference request. Only the service-owned startup is a shared wait.
+        role.loading = startup ? task : null;
+        jobs.add(task);
+        function settled(error, failed) {
+            jobs.delete(task);
+            // An older startup or activation must not replace the selected state.
+            if (role.loading === task) role.loading = null;
+            if (role.changing !== task) return;
+            role.changing = null;
+            if (closed) return;
+            if (failed && startup && !closing) {
+                roleFailed(name, error);
+            } else {
+                role.state = role.engine.current();
+                publish();
+            }
+        }
+        task.then(
+            function speechRoleSettled() { settled(undefined, false); },
+            function speechRoleFailed(error) { settled(error, true); }
+        ).catch(function speechRoleObserverFailed(error) {
+            console.error('Speech role state observer failed.', error);
+        });
+        return task;
+    }
+
     function startRole(name) {
         const role = roles[name];
         if (!role.engine || closing) {
@@ -142,34 +172,60 @@ export function createSpeechService({stt, tts, signal} = {}) {
             roleFailed(name, error);
             return;
         }
+        // Replay can synchronously select an activation or close the service.
+        if (role.changing || closing || closed) return;
         const task = Promise.resolve().then(
             async function loadSpeechEngine() {
                 lifetimeSignal.throwIfAborted();
-                await role.engine.load(
+                if (role.changing !== task) return;
+                return role.engine.load(
                     {signal: lifetimeSignal}
                 );
-                if (!closed) {
-                    role.state = role.engine.current();
-                    publish();
-                }
-            }
-        );
-        role.loading = task;
-        task.then(
-            function speechEngineLoaded() {
-                role.loading = null;
-            },
-            function speechEngineLoadFailed(error) {
-                role.loading = null;
-                if (!closing) {
-                    roleFailed(name, error);
-                }
-            }
-        ).catch(
-            function speechLoadObserverFailed(error) {
-                console.error('Speech load state observer failed.', error);
             }
         );
+        observeRoleTask(name, task, true);
+    }
+
+    function changeRole(operation, parameters, request) {
+        if (closing || closed) {
+            throw failure('CORE_CLOSING', 'The speech service is closing.');
+        }
+        if (!parameters || !is.object(parameters) || is.array(parameters)
+            || !['stt', 'tts'].includes(parameters.role)) {
+            throw failure('SPEECH_ROLE_INVALID', 'Select the stt or tts speech role.');
+        }
+        const {role: name, ...selection} = parameters;
+        const role = roles[name];
+        const operationSignal = request.signal
+            ? AbortSignal.any([lifetimeSignal, request.signal]) : lifetimeSignal;
+        operationSignal.throwIfAborted();
+        if (!role.engine) {
+            throw failure('SPEECH_ENGINE_UNAVAILABLE', `No ${name} speech engine is configured.`);
+        }
+        if (!is.function(role.engine[operation])) {
+            throw failure('SPEECH_OPERATION_UNAVAILABLE', `The ${name} speech engine does not support ${operation}().`);
+        }
+        let acknowledgementFailed = false;
+        let acknowledgementError;
+        const task = Promise.resolve().then(async function changeSpeechRole() {
+            if (acknowledgementFailed) throw acknowledgementError;
+            operationSignal.throwIfAborted();
+            const result = await role.engine[operation]({...selection, signal: operationSignal});
+            operationSignal.throwIfAborted();
+            return result;
+        });
+        // Retain ownership before an acknowledgement observer can close or reenter.
+        observeRoleTask(name, task);
+        try {
+            request.emit?.('speech.progress', {
+                requestId: request.requestId, role: name, operation,
+                status: 'Thinking', progress: {phase: 'accepted'}
+            });
+        } catch (error) {
+            acknowledgementFailed = true;
+            acknowledgementError = error;
+        }
+        return task;
     }
 
     function invoke(name, parameters, request) {
@@ -340,6 +396,12 @@ export function createSpeechService({stt, tts, signal} = {}) {
         },
         methods: {
             'speech.status': current,
+            'speech.load': function load(parameters, request = {}) {
+                return changeRole('load', parameters, request);
+            },
+            'speech.unload': function unload(parameters, request = {}) {
+                return changeRole('unload', parameters, request);
+            },
             'speech.transcribe': function transcribe(parameters, request = {}) {
                 return invoke('stt', parameters, request);
             },

package/src/local-ai/config.mjs

@@ -8,7 +8,17 @@ import {SDXL_BASE_1_0_MODEL} from './image-models/sdxl.mjs';
 import {normalizeWhisperRuntimeRequirement} from './whisper/config.mjs';
 
 const is = new Is(false);
-export const LOCAL_AI_RUNTIME_IDS = ['llama.cpp', 'ollama', 'onnx', 'stable-diffusion.cpp', 'whisper.cpp'];
+export const LOCAL_AI_RUNTIME_IDS = ['llama.cpp', 'ollama', 'onnx', 'stable-diffusion.cpp', 'whisper.cpp', 'kokoro-native'];
+
+/** Describe the selected helper without acquiring it or selecting model assets. */
+export function normalizeKokoroRuntimeRequirement(record) {
+    for (const field of ['helperRoot', 'helperExecutable', 'espeakDataDirectory', 'libraryDirectory']) {
+        if (record[field] !== undefined && (!is.string(record[field]) || record[field] === '')) {
+            throw new ArcaneError(ERROR_CODES.usage, `kokoro-native ${field} must be a nonempty path.`);
+        }
+    }
+    return {...record};
+}
 
 /** Select a llama distribution without discovering hardware or acquiring it. */
 export function normalizeLlamaRuntimeRequirement(record) {
@@ -79,6 +89,7 @@ export function normalizeLocalAIConfig(value) {
         if (record.id === 'llama.cpp') return normalizeLlamaRuntimeRequirement(record);
         if (record.id === 'stable-diffusion.cpp') return normalizeImageRuntimeRequirement(record);
         if (record.id === 'whisper.cpp') return normalizeWhisperRuntimeRequirement(record);
+        if (record.id === 'kokoro-native') return normalizeKokoroRuntimeRequirement(record);
         return {...record};
     });
     return {...value, runtimes};

package/src/local-ai/dev.mjs

@@ -9,7 +9,9 @@ import {normalizeLocalAIConfig} from './config.mjs';
 import {discoverLocalAIRuntimes} from './discover.mjs';
 import {ensureLocalAIRuntimes} from './install.mjs';
 import {createWhisperRuntime} from './whisper/index.mjs';
+import {createNativeKokoroRuntime} from './kokoro/index.mjs';
 import {createExecutionDeviceCatalog} from './execution-devices.mjs';
+import {ArcaneError, ERROR_CODES} from '../errors.mjs';
 
 /** Local engines share the ordinary app-service development transport. */
 export function createDevelopmentLocalAI({
@@ -24,7 +26,7 @@ export function createDevelopmentLocalAI({
     const localConfig = {
         ...selected,
         runtimes: selected.runtimes.filter(function selectedChatRuntime(requirement) {
-            return requirement.id !== 'stable-diffusion.cpp' && requirement.id !== 'whisper.cpp';
+            return !['stable-diffusion.cpp', 'whisper.cpp', 'kokoro-native'].includes(requirement.id);
         })
     };
     const service = createLocalAIService(
@@ -48,7 +50,7 @@ export function createDevelopmentLocalAI({
         return requirement.id === 'stable-diffusion.cpp';
     });
     if (imageSelected || selected.runtimes.some(function selectedProjectedRuntime(requirement) {
-        return ['onnx', 'llama.cpp'].includes(requirement.id);
+        return ['onnx', 'llama.cpp', 'kokoro-native'].includes(requirement.id);
     })) {
         modelAssets = createModelAssetService({appRoot});
         definitions.push(modelAssets);
@@ -71,8 +73,13 @@ export function createDevelopmentLocalAI({
     const whisperRequirement = selected.runtimes.find(function selectedWhisperRuntime(requirement) {
         return requirement.id === 'whisper.cpp';
     });
+    const kokoroRequirement = selected.runtimes.find(function selectedKokoroRuntime(requirement) {
+        return requirement.id === 'kokoro-native';
+    });
+    let stt;
+    let tts;
     if (whisperRequirement) {
-        const stt = createWhisperRuntime(
+        stt = createWhisperRuntime(
             {
                 modelId: whisperRequirement.modelId,
                 temporaryDirectory: path.join(appRoot, '.arcane', 'speech', 'whisper'),
@@ -85,7 +92,49 @@ export function createDevelopmentLocalAI({
                 }
             }
         );
-        speechService = createSpeechService({stt, signal});
+    }
+    if (kokoroRequirement) {
+        tts = createNativeKokoroRuntime({
+            modelId: kokoroRequirement.modelId,
+            model: kokoroRequirement.model,
+            revision: kokoroRequirement.revision,
+            dtype: kokoroRequirement.dtype,
+            paths: kokoroRequirement.paths,
+            assetProjectionId: kokoroRequirement.assetProjectionId,
+            resourcePaths: kokoroRequirement.resourcePaths,
+            sessionOptions: kokoroRequirement.sessionOptions,
+            executionPreference: kokoroRequirement.executionPreference,
+            executionTarget: kokoroRequirement.executionTarget,
+            modelAssets, signal, onEvent,
+            async prepare({signal: activationSignal}) {
+                if (!localConfig.runtimes.some(function selectedONNX(requirement) { return requirement.id === 'onnx'; })) {
+                    throw new ArcaneError(ERROR_CODES.targetUnavailable, 'Native Kokoro requires an explicitly selected onnx runtime.');
+                }
+                const preparation = new AbortController();
+                const preparationSignal = AbortSignal.any([activationSignal, preparation.signal]);
+                function preparationFailed(error) {
+                    preparation.abort(error);
+                    throw error;
+                }
+                // Helper acquisition and the existing ONNX owner's startup are
+                // independent. Join both before native activation can continue.
+                const outcomes = await Promise.allSettled([
+                    waitForKokoroONNX(preparationSignal).catch(preparationFailed),
+                    ensureLocalAIRuntimes({
+                        runtimes: [kokoroRequirement], directory, signal: preparationSignal, onEvent
+                    }).catch(preparationFailed)
+                ]);
+                const failures = outcomes.filter(function failed(result) { return result.status === 'rejected'; })
+                    .map(function cause(result) { return result.reason; });
+                if (failures.length === 1) throw failures[0];
+                if (failures.length) throw new AggregateError(failures, 'Native Kokoro preparation failed.');
+                preparationSignal.throwIfAborted();
+                return {onnx: outcomes[0].value, runtime: outcomes[1].value[0]};
+            }
+        });
+    }
+    if (stt || tts) {
+        speechService = createSpeechService({stt, tts, signal});
         definitions.push(speechService);
     }
     const core = createDevelopmentCore(
@@ -101,6 +150,24 @@ export function createDevelopmentLocalAI({
             }
         }
     );
+    function waitForKokoroONNX(activationSignal) {
+        activationSignal.throwIfAborted();
+        let cancel;
+        const cancelled = new Promise(function observePreparationCancellation(_resolve, reject) {
+            cancel = function stopWaitingForONNX() { reject(activationSignal.reason); };
+            activationSignal.addEventListener('abort', cancel, {once: true});
+        });
+        const ready = core.ready.then(async function existingONNXOwner(runtime) {
+            activationSignal.throwIfAborted();
+            const owner = await runtime.getService('local-ai');
+            activationSignal.throwIfAborted();
+            return owner.getONNXRuntime();
+        });
+        // Cancel this selected activation's wait without stopping the shared owner.
+        return Promise.race([ready, cancelled]).finally(function releaseONNXWait() {
+            activationSignal.removeEventListener('abort', cancel);
+        });
+    }
     function current() {
         return {
             ...core.current(),