arcane-os 0.62.0 → 0.64.0

package/docs/reference/sdk-api.md

@@ -57,15 +57,22 @@ runtime layouts.
 | `arcane-os/core/runtime` | App-neutral native Core dispatcher and service lifecycle. |
 | `arcane-os/core/stdio` | Framed Node stdio transport with graceful runtime drain. |
 | `arcane-os/core/host` | Node-only reusable Core host lifecycle with explicitly supplied services. |
+| `arcane-os/core/repositories` | Native persistent ArcaneData paths and explicitly selected connected working repositories. |
 | `arcane-os/core/packaged-web` | Core-owned packaged web listener with a persisted loopback origin and ready/failure events. |
 | `arcane-os/core/preferences` | Existing preference RPC methods with an application-selected file, ordered writes and owned drain. |
 | `arcane-os/core/diarization` | Lazy native speaker-diarization service, explicit stream methods and lifecycle/result events. |
 | `arcane-os/diarization` | Retained Nemotron model helper and independent caller-fed audio streams. |
 | `arcane-os/diarization/build` | First-party helper compilation against explicitly installed NeMo-Speech.cpp libraries. |
 | `arcane-os/core/local-ai` | Native llama.cpp, Ollama and ONNX Core service, model readiness, complete responses and owned lifecycle. See [local AI through Core](local-ai.md). |
-| `arcane-os/local-ai` | Official runtime installation and native artifact bundling for selected llama.cpp/Ollama/ONNX requirements and NeMo libraries. |
+| `arcane-os/local-ai` | Official runtime installation and native artifact bundling for selected llama.cpp/Ollama/ONNX/image requirements and NeMo libraries. |
 | `arcane-os/local-ai/onnx` | Retained native ONNX worker sessions with explicit graph loading and complete tensor inference. |
 | `arcane-os/ai/core-onnx` | Optional browser access to system ONNX through an existing Core connection. |
+| `arcane-os/local-ai/image` | Retained native stable-diffusion.cpp context, complete PNG generation and owned worker lifetime. |
+| `arcane-os/ai/core-image` | Browser image lifecycle and complete PNG Blobs through an available Core service. |
+| `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/ai/core-model-assets` | Complete stored browser model members projected through Core into native working files. |
+| `arcane-os/core/model-assets` | Native working-file preparation, engine retain handles and joined cleanup. |
 | `arcane-os/integrated-provider` | Fixed integrated shared-development provider. |
 | `arcane-os/packager` | Low-level browser app packager. |
 | `arcane-os/release-bundle` | Deterministic external release bundles. |
@@ -386,6 +393,8 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | `arcaneNativeBuilderProvider default export` | singleton | `arcane-os/native/portable-provider` | Portable native provider | Node; produces a portable payload rather than an executable host |
 | `startCoreHost()` | function | `arcane-os/core/host` | Native Core host composition | Node with readable input and writable output streams |
 | `readCoreLaunchContext()` | function | `arcane-os/core/host` | Native Core host composition | Node; reads explicitly selected launch JSON |
+| `resolveArcaneDataPaths()` | function | `arcane-os/core/repositories` | Native repository workspaces | Node on Windows, Linux and macOS; Android supplies its data root |
+| `createRepositoryWorkspace()` | function | `arcane-os/core/repositories` | Native repository workspaces | Node with Git; Android requires host process adaptation |
 | `createWindowsNativeProvider()` | function | `arcane-os/native/windows-provider` | Windows native provider | Node assembly; Windows x64/WebView2 execution |
 | `arcaneNativeBuilderProvider` | singleton | `arcane-os/native/windows-provider` | Windows native provider | Node assembly; Windows x64/WebView2 execution |
 | `arcaneNativeBuilderProvider default export` | singleton | `arcane-os/native/windows-provider` | Windows native provider | Node assembly; Windows x64/WebView2 execution |
@@ -403,6 +412,15 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | `createLocalAIService()` | function | `arcane-os/core/local-ai` | Core local AI | Node with selected llama.cpp/Ollama/ONNX runtimes |
 | `createONNXRuntime()` | function | `arcane-os/local-ai/onnx` | Core local AI | Node with prepared Microsoft ONNX runtime |
 | `createCoreONNXRuntime()` | function | `arcane-os/ai/core-onnx` | Core local AI | Browser with an available Core ONNX service |
+| `createImageRuntime()` | function | `arcane-os/local-ai/image` | Core local images | Node with a prepared native image runtime and caller-selected model |
+| `createCoreImageRuntime()` | function | `arcane-os/ai/core-image` | Core local images | Browser with an available Core image service |
+| `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 |
+| `createSpeechService default export` | function | `arcane-os/core/speech` | Core native speech | Same shared speech service factory |
+| `prepareCoreModelAssets()` | function | `arcane-os/ai/core-model-assets` | Core model assets | Browser with complete Blob/File members and available Core service |
+| `createModelAssetService()` | function | `arcane-os/core/model-assets` | Core model assets | Node Core with an application-selected working directory |
+| `createModelAssetService default export` | function | `arcane-os/core/model-assets` | Core model assets | Same native working-file service factory |
 | `createLocalAIService default export` | function | `arcane-os/core/local-ai` | Core local AI | Same native service factory |
 | `ensureLocalAIRuntimes()` | function | `arcane-os/local-ai` | Core local AI | Node; selected upstream platform assets |
 | `bundleLocalAIRuntimes()` | function | `arcane-os/local-ai` | Core local AI | Node; complete native runtime assembly |
@@ -7409,12 +7427,23 @@ application builds. The build machine needs its normal Node/npm toolchain and
 The returned `arcane-native-builder/1` provider exposes `describe`, `doctor`,
 `prepare`, `build`, `verify` and `run`. Build returns `{app,target,manifest}`
 with the actual directory at `target.rootDir`. Verification reads the artifact;
-it does not launch the window. Run launches `Arcane.exe` and observes complete
-diagnostics and exit. Cancellation closes input and waits for host-owned drain,
+it does not launch the window. Run launches the executable recorded in the
+saved `manifest.host.executable` and observes complete diagnostics and exit.
+Cancellation closes input and waits for host-owned drain,
 including accepted service work, without a forced termination deadline. Missing
 prerequisites, download/extraction failures and host failures remain observable
 through the operation's error/event boundary.
 
+Assembly names the launcher from `appDescriptor.displayName` plus `.exe`,
+with a matching `.exe.config` file. Low-level compositions without a nonempty
+string display name use the app ID. Windows-reserved filename characters and
+control characters become underscores; reserved DOS device basenames receive
+an underscore prefix. Supported Unicode, spaces and case remain, as do the
+original descriptor and title. Icon embedding, file inventory, verification
+and run use this same name. Existing artifacts retain the executable recorded
+in their manifest; the reusable downloaded host retains `Arcane.exe` and
+`Arcane.exe.config`, and `runtime/ArcaneCore.exe` remains unchanged.
+
 During assembly, `appDescriptor.native.icon` selects the app's existing image.
 PNG and ICO inputs produce a derived `runtime/arcane-app.ico` and update only
 the copied application's executable icon. Source assets, the selected host
@@ -7664,6 +7693,63 @@ separate argument; other composing hosts may use the same seam. This JavaScript
 contract does not establish a compiled host or matching release archive. See
 [launch-time locations](core-native-packaging.md#launch-time-locations).
 
+## resolveArcaneDataPaths()
+
+### Overview
+
+Resolves the native per-user `ArcaneData` directory and its `Repos` child without
+creating directories or changing application state.
+
+### Signature and result
+
+```text
+resolveArcaneDataPaths({dataRoot}={})
+```
+
+Returns absolute `{dataRoot,repositoriesRoot}`. Defaults use Windows LocalAppData,
+Linux XDG data home or `~/.local/share`, and macOS user Application Support.
+Android and other adapted hosts supply their persistent `dataRoot`. An explicit
+root is used directly, with relative paths resolved from the process working
+directory. See [native repository locations](core-repositories.md#persistent-locations).
+
+```javascript
+import {resolveArcaneDataPaths} from 'arcane-os/core/repositories';
+
+const {repositoriesRoot} = resolveArcaneDataPaths();
+```
+
+## createRepositoryWorkspace()
+
+### Overview
+
+Owns one native connected working checkout under `ArcaneData/Repos/<name>` or an
+explicit existing path. The application owns the remote, branch and Core API.
+
+### Signature and result
+
+```text
+createRepositoryWorkspace({name,directory,dataRoot,remote,branch,onEvent,run=runProcess}={})
+```
+
+Returns `{directory,open,status,pull,push,close,drain,dispose}`. Construction does
+no I/O. Operations accept `{signal}`; a missing or empty destination clones once,
+while existing checkout files, branches, remotes and local changes remain intact.
+Same-directory calls are ordered within the process. Shutdown drains accepted
+work and preserves the checkout. No CLI cwd, launch state, preference, snapshot
+cache or existing user-data location changes. See the [complete inputs, results,
+errors and lifecycle](core-repositories.md#one-connected-working-checkout).
+
+```javascript
+import {createRepositoryWorkspace} from 'arcane-os/core/repositories';
+
+const repository = createRepositoryWorkspace({
+    name: 'moon-cheese-dispatches',
+    remote: applicationConnection.remote
+});
+await repository.open({signal});
+await repository.close();
+```
+
 ## createCoreLocalAIProvider()
 
 ### Overview
@@ -7708,7 +7794,7 @@ separate states; prompts, models and application policy remain caller-owned.
 ### Signature and result
 
 ```text
-createLocalAIService(configuration,{appRoot,runtimes=[],signal,onEvent}={})
+createLocalAIService(configuration,{appRoot,runtimes=[],signal,onEvent,prepare}={})
 ```
 
 Import it from `arcane-os/core/local-ai`. `configuration` is the authored local-AI
@@ -7718,6 +7804,13 @@ resolved installed runtime records. It returns a Core service definition with
 existing Core lifecycle. Shutdown cancels owned work and joins owned processes;
 an already running external service remains under its external owner.
 
+Optional `prepare({signal,onEvent})` supplies resolved runtime records during
+this service's startup. Only operations depending on that service wait for its
+preparation; the development listener and independently composed image/model
+asset services keep their own lifetimes. Pass only llama.cpp/Ollama/ONNX
+requirements to this factory; `createLocalImageService()` owns selected image
+requirements. The managed development and native entrypoints separate them.
+
 The service provides `localai.status`, explicit `localai.services.recover`,
 `llama.status/models/load/unload/chat`, `onnx.status/load/run/unload`, and the documented native Ollama methods.
 `localai.state` reports runtime/model changes. `llama.chunk` and `ollama.chunk`
@@ -7761,6 +7854,231 @@ accessor's requests and subscriptions; unloading shared models is explicit.
 Construction installs no runtime and opens no transport. Existing browser
 ONNX/Wllama remain independent. See [Core and browser usage](local-ai.md#onnx-through-core-and-the-browser).
 
+## createImageRuntime()
+
+`createImageRuntime({libraryPath,bindingModulePath,variants=[],models=[],backend='auto',signal?,onEvent?})`
+from `arcane-os/local-ai/image` retains the native image owner for the selected
+library. Prepare the installed record through `ensureLocalAIRuntimes()` and
+supply complete model descriptors with actual native resource paths. The
+factory installs no software and starts its worker when an operation needs it.
+
+It returns `load({model,context?,signal?})`, `generate({model,prompt,parameters?,
+signal?,onProgress?})`, `edit({model,image,prompt,strength,parameters?,signal?,onProgress?})`,
+`unload({signal?})`, `current()`,
+`subscribe(listener,{replay=true})` and asynchronous `close()`. A model ID uses
+its supplied descriptor; a complete descriptor may be passed directly.
+Generation returns all PNG results as `images: [{data,mediaType,width,height}]`
+with native result metadata. Prompts and parameters remain complete.
+
+`edit()` accepts the original complete PNG as `image: {data: Uint8Array,
+mediaType}` and copies the supplied view at acceptance. Its explicit finite
+`strength` is from `0` through `1`, takes precedence over model/parameter
+defaults and is never clamped. It decodes in the existing worker and uses the
+same selected context, queue, progress, cancellation and complete result
+contract. SD1.4 advertises `txt2img` and `img2img`. See the
+[editing contract](local-image-editing.md#core-and-native-request) for supported
+PNG input, native preprocessing, alpha and strength-zero semantics; the
+original file remains unchanged.
+
+Accessors for the same library share its worker and selected context. Competing
+native operations are ordered at that owner; unrelated services remain
+concurrent. State observation replays synchronously by default. Cancellation
+joins the owning native operation; a model constructor may finish before its
+new context can be released. Native accessor `close()` cancels its requests,
+joins them and releases the shared selected context before its working files
+can be retired. The final reference closes the worker. This differs from the
+browser accessor's detach-only ownership below. See the
+[image lifecycle, backend and error contract](local-image-generation.md).
+
+## createCoreImageRuntime()
+
+`createCoreImageRuntime({client=getInstalledCoreClient(),signal?,onEvent?})`
+from `arcane-os/ai/core-image` returns immediately with `load`, `generate`, `edit`,
+`unload`, `inspect`, `current`, `subscribe` and `close`. It subscribes before
+requesting an initial status snapshot so newer lifecycle events win. It opens
+no connection and installs or selects no model.
+
+`load({model,context?,assetProjectionId?,resourcePaths?,signal?})` and
+`generate({model,prompt,parameters?,assetProjectionId?,resourcePaths?,signal?,
+onProgress?})` use the selected Core service. Generation acknowledges with
+transient `Thinking` synchronously and returns complete
+`images: [{blob,mediaType,width,height}]` plus native result metadata.
+`unload({signal?})` explicitly releases the shared selected model;
+`inspect({signal?})` reads authoritative state without waiting for preparation.
+All request methods use `timeoutMs:0`. `current()` includes transient requests,
+status, busy and closed state; no prompt or image history is saved.
+
+`edit({model,image,prompt,strength,parameters?,assetProjectionId?,resourcePaths?,
+signal?,onProgress?})` accepts the original PNG Blob or File and returns the
+same complete Blob result shape. It publishes `Thinking` before reading that
+input, preserves its complete encoded content through Core, and performs no
+browser drawing, re-encoding, resizing or saving. The request signal covers
+input preparation and native cancellation; an in-flight `Blob.arrayBuffer()`
+finishes before cancellation can be observed. No aborted result or late
+progress reaches the caller. See [full editing usage and format limits](local-image-editing.md).
+
+`subscribe(listener,{replay=true,signal?})` returns an unsubscribe function.
+`close()` cancels and joins only this accessor's requests and subscriptions,
+leaving the shared Core client and selected model with their owners. Request
+errors retain complete details; an unavailable Core reports
+`ARCANE_IMAGE_CORE_UNAVAILABLE`. Aborted operations deliver no late result or
+progress. See the [complete browser example and events](local-image-generation.md#browser-accessor).
+
+## createLocalImageService()
+
+`createLocalImageService(configuration,{appRoot,runtimes=[],signal?,onEvent?,prepare?,modelAssets?})`
+from `arcane-os/core/image` returns a Core service with `current()`, replaying
+`subscribe(listener)`, native preparation, request methods and joined disposal.
+`configuration` is the selected `localAI` record. Optional
+`prepare({appRoot,configuration,requirement,signal,onEvent})` returns one
+installed image-runtime record. Startup retains this preparation in the
+background; `image.status` and unrelated services remain responsive.
+
+The service owns `image.status/load/generate/edit/unload` and
+`image.state/progress`. Pass the same `createModelAssetService()` instance that
+Core exposes when using `assetProjectionId` and `resourcePaths`. It retains
+prepared model files through actual native completion, replacement, unload and
+shutdown. PNG base64 is transport-only framing; the complete result is decoded
+by the browser accessor. See [parameters, results and ownership](local-image-generation.md#core-service-and-transport).
+
+`image.edit` takes `{model,image,prompt,strength,parameters?,streamId?,
+assetProjectionId?,resourcePaths?}`. Only the Core JSON boundary encodes the
+input as `{data: completeBase64PNG,encoding:'base64',mediaType}`. The service
+acknowledges accepted work through `image.progress`, preserves the original
+prompt and complete image, and retains existing model-assets ownership through
+native completion. Its complete encoded PNG result has the same shape as
+`image.generate`; [editing semantics](local-image-editing.md) remain with the
+selected model and native engine.
+
+## createLocalImageService default export
+
+The default export from `arcane-os/core/image` is the same
+`createLocalImageService` factory and lifecycle described above.
+
+## createSpeechService()
+
+### Overview and usage
+
+`createSpeechService({stt,tts,signal}={})` from `arcane-os/core/speech` composes
+independently selected STT and TTS engines as one Core service. Supply either
+role or both. Construction downloads, installs and loads nothing; the host
+owns engine creation, model/device selection and supported formats.
+
+```javascript
+import {createCoreRuntime} from 'arcane-os/core/runtime';
+import {createSpeechService} from 'arcane-os/core/speech';
+
+// transcriptionEngine is the host's already constructed, selected engine.
+const speech = createSpeechService({stt: transcriptionEngine});
+const core = createCoreRuntime({services: [speech]});
+core.start();
+```
+
+Each supplied engine exposes `current()`, replaying `subscribe(listener)`,
+`load({signal})`, `close()` and its role's
+`transcribe(request,{signal,onProgress})` or
+`synthesize(request,{signal,onProgress})`. The service forwards complete
+requests and results unchanged. Format decoding, model processing and encoding
+remain with that engine. This factory supplies no speech engine or automatic
+browser/native provider selection.
+
+### Members, results and events
+
+The returned object has `name: 'speech'`, `current`, `subscribe`, `close`,
+`start`, `methods`, `drain` and `dispose`:
+
+- `start(context)` subscribes and starts both configured engine loads
+  independently, returning immediately. Core and status remain responsive
+  during loading; one role's failure leaves the other usable.
+- `current()` and `methods['speech.status']()` return the same snapshot:
+  `ready`, `transcriptionAvailable`, `synthesisAvailable`, `status`,
+  `sttEngine`, `ttsEngine`, `roles.stt`, `roles.tts` and `closed`.
+  `ready` requires both roles; each independent availability flag requires
+  its model loaded in `ready` or `running` state while the service accepts work.
+  `status` is `created`, `ok`, `closing` or `closed`; per-role state carries
+  model loading, progress and complete errors. An omitted role is unavailable.
+- `subscribe(listener,{replay=true,signal}={})` replays current state by
+  default and returns an unsubscribe function. Its signal owns only that
+  subscription; a closed service can replay its final snapshot.
+- `methods['speech.transcribe'](request,context)` and
+  `methods['speech.synthesize'](request,context)` are registered as the matching
+  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.
+- `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.
+
+`speech.state` carries the complete snapshot. `speech.progress` carries
+`{requestId,role,status:'Thinking',progress}` with initial
+`progress:{phase:'accepted'}`. The service's subscription replays state; Core's
+generic runtime replay does not replay this custom event. Browser consumers
+subscribe before requesting `Arcane.speech.status()` and preserve any newer
+state event received while that request is pending.
+
+### Cancellation, errors and availability
+
+The optional factory signal owns the service lifetime. A request signal is
+combined with that lifetime and reaches its selected engine. Cancelling one
+request waiting for a shared load settles that request without cancelling
+the other requests or role. No later cancelled progress or result is delivered.
+Actual queued/running native interruption belongs to the engine; it must settle
+before Core reaches service shutdown, because Core first cancels and awaits
+active requests.
+
+Invalid engine interfaces or listeners throw `TypeError`. Missing roles reject
+their operation with `SPEECH_ENGINE_UNAVAILABLE`; work after shutdown begins
+rejects with `CORE_CLOSING`. Engine errors remain observable, and engine cleanup
+failures reject shutdown with `AggregateError`. Asynchronous listener failures
+reach developer diagnostics. Engine platform support remains its own contract;
+this Node composition layer adds no engine dependency. Existing AI readiness
+consumers recognize `whisper.cpp` and `kokoro-onnx` IDs independently of the
+service's engine-neutral interface. See the [complete engine and lifetime
+contract](native-speech.md).
+
+## createSpeechService default export
+
+The default export from `arcane-os/core/speech` is the same
+`createSpeechService` factory, with identical inputs, results and lifecycle.
+
+## prepareCoreModelAssets()
+
+`prepareCoreModelAssets({client=getInstalledCoreClient(),workingDirectory,members,signal?,onProgress?})`
+from `arcane-os/ai/core-model-assets` projects ordered complete
+`members: [{path,file}]` through an available Core connection. Each `file` is a
+Blob or File. It returns `{id,directory,members:[{path,nativePath}],release}`
+after all members finish writing and close. Independent members transfer
+concurrently; each member's writes remain ordered.
+
+The caller releases preparation ownership with asynchronous idempotent
+`release()`. Native engines acquire their own retain handle before loading,
+and files remain until their actual native use ends. Cancellation and failure
+join transfers and uncancelled cleanup, preserving complete original errors.
+The helper downloads no model, changes no DBOPFS original and selects no
+engine. See [complete preparation and cleanup usage](model-assets.md).
+
+## createModelAssetService()
+
+`createModelAssetService({appRoot=process.cwd()}={})` from
+`arcane-os/core/model-assets` returns the Core service for
+`modelAssets.open/write/complete/release/status` and `modelAssets.state`.
+Relative working directories resolve from `appRoot`; explicit absolute
+directories remain caller-selected. Each projection has its own child
+directory and complete member files.
+
+`current()` returns `{closing,projections}`. `retain(id)` accepts a completed
+projection and returns `{id,directory,members,release}` for a native owner.
+`dispose()` releases preparation ownership and joins file writes, closes and
+all native retain lifetimes before cleanup. The native owner releases its
+handle only after its actual context/worker use ends. Original stored model
+files remain with their application owner. See
+[working-file service and wire operations](model-assets.md#native-ownership).
+
+## createModelAssetService default export
+
+The default export from `arcane-os/core/model-assets` is the same
+`createModelAssetService` factory and lifecycle described above.
+
 ## createLocalAIService default export
 
 The default binding from `arcane-os/core/local-ai` is exactly the named
@@ -7776,7 +8094,7 @@ import createLocalAIService from 'arcane-os/core/local-ai';
 ### Overview
 
 Reuses matching managed runtimes or installs complete selected official
-llama.cpp/Ollama/ONNX distributions or NeMo libraries in an explicitly supplied directory.
+llama.cpp/Ollama/ONNX/image distributions or NeMo libraries in an explicitly supplied directory.
 
 ### Signature and result
 
@@ -7787,7 +8105,11 @@ async ensureLocalAIRuntimes({runtimes=[],directory,platform=process.platform,arc
 Import it from `arcane-os/local-ai`. Runtime requirements accept IDs or
 `{id,version?,url?}` records. The result is an array of absolute
 `{id,version,platform,architecture,root}` records, with `executable` for servers,
-`modulePath` for ONNX, or NeMo library directories. Matching concurrent
+`modulePath` for ONNX, image `libraryPath`/`bindingModulePath`/`variants`/`models`,
+or NeMo library directories. 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).
+Matching concurrent
 installs share their work. Downloads retain runtime libraries and surface
 network/archive failures; cancellation and operation events remain observable.
 Installation changes no global PATH or system service and loads no model.
@@ -7825,6 +8147,13 @@ contains the complete emitted inventory. Existing runtime destinations are
 preserved and reported as a conflict. Copying settles all started work and
 reports failures/cancellation without executing app services or models.
 
+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;
+external working paths report their portability incompatibility rather than
+embedding this machine's path. Use the application-owned native-resource or
+post-launch model-assets workflow for those files.
+
 ```javascript
 import {bundleLocalAIRuntimes} from 'arcane-os/local-ai';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.62.0",
+  "version": "0.64.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -61,17 +61,21 @@
     "./core/runtime": "./src/core/runtime.mjs",
     "./core/stdio": "./src/core/stdio.mjs",
     "./core/host": "./src/core/host.mjs",
+    "./core/repositories": "./src/core/repositories.mjs",
     "./core/packaged-web": "./src/core/services/packaged-web.mjs",
     "./core/preferences": "./src/core/services/preferences.mjs",
     "./core/diarization": "./src/diarization/service.mjs",
     "./core/local-ai": "./src/core/services/local-ai.mjs",
     "./core/image": "./src/core/services/image.mjs",
+    "./core/speech": "./src/core/services/speech.mjs",
     "./core/model-assets": "./src/core/services/model-assets.mjs",
     "./diarization": "./src/diarization/index.mjs",
     "./diarization/build": "./src/diarization/build.mjs",
     "./local-ai": "./src/local-ai/install.mjs",
     "./local-ai/onnx": "./src/local-ai/onnx.mjs",
     "./local-ai/image": "./src/local-ai/image-runtime.mjs",
+    "./local-ai/whisper": "./src/local-ai/whisper/index.mjs",
+    "./local-ai/whisper/build": "./src/local-ai/whisper/build.mjs",
     "./integrated-provider": "./src/integrated-provider-loader.mjs",
     "./packager": "./src/packager/core.mjs",
     "./release-bundle": "./src/release-bundle.mjs",

package/runtime/arcane/components/speech.html

@@ -295,6 +295,7 @@
     const aiModuleImport = import('../modules/AI.js');
     const providerRuntimeImport = import('../modules/AIProviderRuntime.js');
     const {
+        continuesAIRuntimeOperation,
         requestAIRuntimeIntent,
         subscribeAIRuntimeState
     } = await import('../modules/AIRuntimeState.js');
@@ -366,6 +367,7 @@
     let ttsIntentGeneration = 0;
     let eventOperationSequence = 0;
     let transcriptionOperationId = null;
+    let transcriptionRuntimeOperationId = null;
     let ttsOperationId = null;
     let destroyed = false;
     let recognitionLanguage = is.string(host.recognitionLanguage)
@@ -826,8 +828,10 @@
 
     function applyRoleTransitions(previousSTTRole, previousTTSRole) {
         sttActivationController?.synchronize(sttRole);
-        const sttBecameUnready = previousSTTRole.state === 'ready'
-            && sttRole.state !== 'ready';
+        const continuingTranscription = transcriptionActive && !nativeCaptureSession
+            && continuesAIRuntimeOperation(previousSTTRole, sttRole, transcriptionRuntimeOperationId);
+        const sttBecameUnready = ['ready', 'recovering'].includes(previousSTTRole.state)
+            && sttRole.state !== 'ready' && !continuingTranscription;
         const ttsBecameUnready = previousTTSRole.state === 'ready'
             && ttsRole.state !== 'ready';
 
@@ -2011,10 +2015,16 @@
                 throw error;
             }
 
-            const transcription = await aiRuntime.fetchSTT(
+            const previousRuntimeOperationId = providerRuntime.status('stt').operationId;
+            const pendingTranscription = aiRuntime.fetchSTT(
                 audioFile,
                 controller.signal
             );
+            const activeRole = providerRuntime.status('stt');
+            transcriptionRuntimeOperationId = activeRole.busy
+                && activeRole.operationId !== previousRuntimeOperationId
+                ? activeRole.operationId : null;
+            const transcription = await pendingTranscription;
             if (
                 generation !== transcriptionGeneration
                 || sttRole.state !== 'ready'
@@ -2044,6 +2054,7 @@
         } finally {
             if (transcriptionAbortController === controller) {
                 transcriptionAbortController = null;
+                transcriptionRuntimeOperationId = null;
             }
             if (generation === transcriptionGeneration) {
                 transcriptionActive = false;
@@ -2144,6 +2155,7 @@
         transcriptionGeneration += 1;
         transcriptionAbortController?.abort();
         transcriptionAbortController = null;
+        transcriptionRuntimeOperationId = null;
         recordingRequested = false;
         transcriptionActive = false;
         clearSilenceTimer();

package/runtime/arcane/components/voice-transcription.html

@@ -135,7 +135,7 @@
     const [
         {default:MD},
         {appendTranscription,createSTTActivationController,normalizeVoiceOptions},
-        {requestAIRuntimeIntent,subscribeAIRuntimeState},
+        {continuesAIRuntimeOperation,requestAIRuntimeIntent,subscribeAIRuntimeState},
         {default:ContinuousVoiceCapture},
         {getAIProviderRuntime}
     ]=await Promise.all([
@@ -165,6 +165,7 @@
     let recorder=null;
     let state='idle';
     let stateMessage='';
+    let transcriptionRuntimeOperationId=null;
     let sttRole=unavailableRole('stt');
     let transcript='';
     let sessionGeneration=0;
@@ -1121,7 +1122,17 @@
             error.code='ARCANE_VOICE_TRANSCRIPTION_STT_RUNTIME_METHOD_UNAVAILABLE';
             throw error;
         }
-        return globalThis.ai.fetchSTT(file,signal);
+        const previousOperationId=providerRuntime.status('stt').operationId;
+        const pending=globalThis.ai.fetchSTT(file,signal);
+        const activeRole=providerRuntime.status('stt');
+        const operationId=activeRole.busy&&activeRole.operationId!==previousOperationId
+            ?activeRole.operationId:null;
+        transcriptionRuntimeOperationId=operationId;
+        try{
+            return await pending;
+        }finally{
+            if(transcriptionRuntimeOperationId===operationId)transcriptionRuntimeOperationId=null;
+        }
     }
 
     function isTranscriptionCancellation(error,controller){
@@ -1417,6 +1428,9 @@
     function synchronizeAIRuntimeState(snapshot){
         const previousRole=sttRole;
         sttRole=snapshot.roles.stt;
+        const continuingTranscription=continuesAIRuntimeOperation(
+            previousRole,sttRole,transcriptionRuntimeOperationId
+        );
         if(sttRole.state==='error'&&previousRole.state!=='error'){
             arcaneLogging.error('Arcane transcription runtime failed.',sttRole.error);
         }
@@ -1438,6 +1452,7 @@
                 return;
             }
             if(session.processing==='transcribing'
+                &&!continuingTranscription
                 &&(sttRole.state!=='ready'
                     ||previousRole.providerId!==sttRole.providerId
                     ||previousRole.modelId!==sttRole.modelId)){
@@ -1447,7 +1462,8 @@
             renderContinuousState(session);
             return;
         }
-        if(previousRole.state==='ready'&&sttRole.state!=='ready'){
+        if(['ready','recovering'].includes(previousRole.state)
+            &&sttRole.state!=='ready'&&!continuingTranscription){
             if(cancelSTTOperation('runtime-unready')){
                 return;
             }