arcane-os 0.55.0 → 0.57.0

package/docs/reference/protocols.md

@@ -88,9 +88,11 @@ Explicit host document lists use the separate root-exported
 described below; they do not enter app discovery.
 
 The application dependency boundary is conditional. Only an application that
-actually consumes Arcane declares one exact published `arcane-os` version in
-its own `package.json` and resolves it through that project's normal install
-into its own `node_modules`. An application that does not currently consume
+actually consumes Arcane declares `arcane-os` in its own `package.json` and
+resolves it through that project's normal install into its own `node_modules`.
+During development the declaration tracks `latest`; the lockfile and installed
+package record the exact selected version. An explicitly selected production
+build may declare an exact version. An application that does not currently consume
 Arcane adds no `arcane-os` dependency solely because of this rule; the user or
 governing task may direct that application to adopt Arcane later, at which point
 the same app-owned package, install, projection, and artifact boundary applies.
@@ -145,9 +147,70 @@ included resources without receiving application-document processing.
 Component processing and shared runtime-resource traversal retain their existing
 behavior. Offline inclusion still follows the app's PWA resource selection.
 
+## Native-only application resources
+
+An application's schema-2 `arcane-app.json` can explicitly select server modules
+and their complete app-owned source closure without adding them to its browser
+or PWA output:
+
+```json
+{
+  "package": {
+    "include": ["index.html", "modules", "css"],
+    "nativeResources": {
+      "include": ["server", "src", "package.json"],
+      "exclude": ["server/drafts"]
+    }
+  }
+}
+```
+
+This is a package excerpt. Each path is literal and relative to the application
+root; a directory includes its descendants. The app selects the full required
+closure explicitly. The SDK does not crawl imports to discover server source,
+filter it by extension, install app dependencies or execute a service.
+`nativeResources.include` is required and may be empty; `exclude` defaults to
+`[]`. Descriptor projection writes the same record at the top level of schema-1
+`arcane-package.json`, and package-only apps may author it there directly.
+Omission remains omission. The native registry descriptor is unchanged.
+
+`packageApp({target})` and `inspectApp({target})` default to `'browser'`. A
+nonbrowser SDK target adds these resources to the ordinary app/shared selection.
+Native exclusions apply only to the additional selection, not the browser
+selection. A file selected by both is emitted once through its ordinary browser
+processing. Files selected only as native resources retain their complete
+original content, including imports, HTML, line endings and data. They are copied
+after browser document discovery, module projection, asset rewriting and PWA
+processing, and appear in the complete release inventory. A collision with
+generated output reports an error instead of replacing that output.
+
+Target and module representation are independent: `moduleFormat:'native'`
+controls browser module/script packaging and does not select native resources.
+Nonbrowser targets use effective `browserPwa:false`; ordinary browser calls keep
+their configured PWA behavior. An app adapter receives `target` and effective
+`browserPwa` in its existing `buildArcanePackage()` context. Its `copyBase()`
+copies ordinary browser/shared files; the packager appends native-only files
+after the adapter and browser transformations finish.
+
+A nonbrowser target with a nonempty native include list writes its app input to
+`dist/.native/<target>/<app-id>`, even when the saved browser `outputDirectory`
+is custom. This keeps an existing browser/PWA output separate. An explicit
+low-level `outputDirectory` override takes precedence; it must name the
+dedicated output the caller intends to replace. Omitted or empty native
+resources preserve the existing output rules. `inspectApp()` reports the
+effective `output` and complete selected files without writing them.
+
+Paired native `buildApplication()` applies the same selected target and output
+resolution to the selected app and every explicitly bundled app. Each app keeps
+its own declaration; the provider receives actual release roots and complete
+release records. Native artifact `outputRoot` remains a different directory.
+Use `verifyApp({workspaceRoot,appId,outputDirectory:release.output})` to inspect
+that emitted app release; verification does not launch its services or host.
+See [the portable service composition guide](core-native-packaging.md#native-only-application-resources).
+
 ## App-selected package output
 
-An app may set `"outputDirectory": "ai"` in its schema-1
+For browser selection, an app may set `"outputDirectory": "ai"` in its schema-1
 `arcane-package.json`. This selects the final directory relative to the
 workspace: `<workspace>/ai`, not `<workspace>/ai/<app-id>`. Omitting the
 field retains `dist/<app-id>`. The root `arcane-packager.json` configuration
@@ -183,6 +246,10 @@ output must remain separate; a conflicting native assembly fails before it
 packages any app. App launch paths, resource URLs, and enabled PWA
 representations retain their package-relative layout.
 
+The [native-only resource selection](#native-only-application-resources) above
+adds a separate default native input directory when its include list is nonempty.
+An explicit low-level output override still selects the exact directory to replace.
+
 ## Native-module package output
 
 The public `packageApp` operation accepts `moduleFormat:'native'`. Omission, or
@@ -191,6 +258,9 @@ The public `packageApp` operation accepts `moduleFormat:'native'`. Omission, or
 accepts that same override. Configuration, source layout, app identity, storage
 scope and previously generated sibling outputs remain unchanged.
 
+This module format does not select a native target. Use the separate `target`
+option for [native-only resources](#native-only-application-resources).
+
 The native transformation runs in the selected package stage after application
 adapter work, before the final inventory and any enabled PWA artifacts. It uses
 the existing selected document/runtime records and shared lexical/HTML owners.
@@ -381,10 +451,11 @@ layouts; the default nested scaffold continues to use its development dependency
 ## Installed SDK runtime materialization
 
 `materializeInstalledSdkRuntime()` is the Node entrypoint for refreshing one
-external workspace's checked-in `arcane/` projection from its one exact
-installed SDK declaration. Import the function through the dependency key that
+external workspace's checked-in `arcane/` projection from its one declared and
+installed SDK dependency. Import the function through the dependency key that
 the workspace actually declares: `arcane-os` for the canonical package name or,
-for example, `arcane-sdk` for the exact `npm:arcane-os@<version>` alias. No
+for example, `arcane-sdk` for the development alias `npm:arcane-os@latest`. The
+lockfile and installed package retain the exact resolved version. No
 application- or Arcane OS-local copier owns this operation.
 
 The operation resolves that declaration while holding the shared
@@ -563,8 +634,8 @@ exactly `dependencyName`, `packageSource`,
 `canonicalPackageRoot`, `packageName`, `packageVersion`, `runtimeRoot`,
 and `browserRuntimeRoot`. A
 workspace may use the canonical dependency name or one npm alias such as
-`npm:arcane-os@0.51.1`; the installed package manifest identifies `arcane-os`
-and supplies its actual version. The resolver requires one declaration and a
+`npm:arcane-os@latest`; the installed package manifest identifies `arcane-os`
+and supplies its actual exact version. The resolver requires one declaration and a
 direct physical installation with runtime and browser-runtime directories.
 The application's normal npm declaration and lockfile own version selection.
 
@@ -999,9 +1070,12 @@ reachable.
 
 ### macOS
 
-No macOS target, native bridge, Core host, artifact, or run contract is exposed
-by this SDK version. A browser may still run browser-only application code, but
-that does not create a native Arcane host or satisfy a native capability.
+No macOS executable target, native bridge, platform host, artifact, or run
+contract is exposed by this SDK version. A browser may still run browser-only
+application code. A separately composed macOS host may use the reusable Node
+Core runtime, framed stdio transport, host composition, and portable payload,
+but those SDK primitives do not create a native bridge or executable host and
+do not by themselves satisfy a native capability.
 
 ## Development and remote HTTP transport
 
@@ -1083,8 +1157,11 @@ The common contract ends where platform truth must remain different:
   artifact kind, and some diagnostic/result fields remain platform-specific;
 - unsupported platforms fail or return a documented unsupported state; they do
   not run an unrelated browser implementation as a substitute;
-- this SDK version requires a selected checkout and Core to provide the current
-  native plan's protocol, version, feature, capability, method, and provider;
+- the portable target defaults to the installed SDK provider and assembles a
+  non-executable payload without an Arcane OS checkout;
+- executable native targets require their explicit checkout/provider, and the
+  composed host must supply the protocol, version, features, capabilities,
+  methods, and services that its application contract requires;
 - that current-build compatibility does not promise that a future SDK will accept
   this Core or that this SDK will accept a future Core.
 

package/docs/reference/pwa.md

@@ -206,6 +206,23 @@ manifest carries release information. Non-PWA and native packaging use the same
 [clean local resource URLs](asset-versioning.md). Native packaging does not
 generate the browser PWA worker, installation manifest or registration bootstrap.
 
+## Package without browser PWA output
+
+Select `browserPwa:false` for an artifact, such as an application directory
+inside an extension-owned root. The package omits `arcane.webmanifest`,
+`arcane-offline.json`, `arcane-sw.js`, and `arcane-pwa.mjs`. Before native-module
+processing, it removes active SDK-marked `data-arcane-pwa` scripts and manifest
+relationships that resolve to that package's `arcane.webmanifest` from the
+selected application document set.
+
+This is a package-output choice, not a source or saved-setting change. It
+preserves unrelated manifest links and link relationships, comments, templates,
+other inactive HTML, unselected documents, and authored PWA configuration. The
+application remains responsible for any extension manifest, permissions,
+background process, toolbar launcher, or other outer host. See the
+[native-module output contract](protocols.md#native-module-package-output) and
+[`packageApp()` options](sdk-api.md#packageapp) for the complete boundary.
+
 ## Development and hosting
 
 Use the ordinary `arcane dev --app <id>` command after editing the selected

package/docs/reference/runtime-modules.md

@@ -2252,10 +2252,11 @@ and `read`, filters source metadata before calling
 ### Availability and normalization
 
 **Browser or compatible host with an injected DBOPFS adapter.** The adapter
-keeps the existing `get`, `set`, `getAllKeys`, and `delete` method names; Node
-can use the same class only through an explicitly imported runtime module and a
-compatible storage adapter; SDK `0.5.12` publishes no Node package subpath or
-Node storage implementation for it. Bootstrap uses a concurrent
+keeps the existing `get`, `set`, `getAllKeys`, and `delete` method names. Node
+callers import the same class and factory from the public
+`arcane-os/dbopfs-document-library` subpath and supply a compatible storage
+adapter. That export supplies no Node filesystem storage implementation.
+Bootstrap uses a concurrent
 generation, commits its manifest last, cleans partial data on failure, and
 rejects case-colliding IDs. Search
 returns `{failures,matches,total}` so one malformed record remains visible
@@ -2414,7 +2415,7 @@ const search = new DocumentLexicalSearch([{
   kind: 'guide',
   tags: ['intro']
 }]);
-console.log(search.search('portable', {limit: 5}));
+console.log(search.search('portable'));
 ```
 
 ## DocumentNavigation.js

package/docs/reference/sdk-api.md

@@ -55,6 +55,8 @@ 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/local-ai` | Native llama.cpp and Ollama Core service, model readiness, complete streaming and owned process 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 requirements. |
 | `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. |
@@ -83,6 +85,7 @@ runtime layouts.
 | `arcane-os/browser-device` | Synchronous mobile or desktop identity hints for application-owned settings. |
 | `arcane-os/pwa` | Nonblocking PWA registration, worker updates, native installation state and a dismissible installation component. |
 | `arcane-os/ai/browser-wasm` | Caller-selected browser-local Wllama inference, complete DBOPFS model storage, streaming, cancellation, and structural tool-call results. |
+| `arcane-os/ai/core-local` | Browser llama.cpp provider through an available Core connection; browser-local Wllama and ONNX remain independently available. |
 | `arcane-os/ai/browser-decisions` | Explicit-load Laya FP16 and Julia-1 FP32 typed decisions through the shared Transformers.js Worker owner. |
 | `arcane-os/ai/tool-text-stream` | Shared selected tool-argument text observer for provider integration. |
 | `arcane-os/ai/twin-cloud` | Stateless chat, System One state/questions and image generation with explicit key/model, complete results and operation-specific retry/cancellation. |
@@ -362,6 +365,7 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | `createCoreClient()` | function | `arcane-os/core/client` | Core browser client | Browser and native WebView JavaScript hosts |
 | `createCoreFacade()` | function | `arcane-os/core/client` | Core browser client | Browser and native WebView JavaScript hosts |
 | `installCoreClient()` | function | `arcane-os/core/client` | Core browser client | Browser and native WebView JavaScript hosts |
+| `getInstalledCoreClient()` | function | `arcane-os/core/client` | Core browser client | Browser and native WebView JavaScript hosts |
 | `createCoreClassicSource()` | function | `arcane-os/core/classic-source` | Core classic client projection | Node; generated source runs in browser and native WebView renderers |
 | `createCoreRuntime()` | function | `arcane-os/core/runtime` | Native Core runtime | Node on Windows, Linux and macOS native hosts; Android requires host adaptation |
 | `encodeCoreFrame()` | function | `arcane-os/core/stdio` | Native Core stdio transport | Node |
@@ -807,7 +811,7 @@ descriptor-selected browser document inventory.
 ### Signature and result
 
 ```text
-async inspectApp({workspaceRoot, appId, signal}={})
+async inspectApp({workspaceRoot, appId, signal, target, outputDirectory}={})
 ```
 
 Import it from `arcane-os` or `arcane-os/packager`. The result includes the
@@ -834,9 +838,18 @@ such as `apps/hello-world/index.html`. The complete `files` inventory uses
 package-relative paths and includes the root `index.html`. Shared
 files retain their configured route destinations.
 
-`output` is the selected workspace-relative final package directory. It uses
-the app's optional `arcane-package.json` `outputDirectory` directly, or
-`dist/<app-id>` when omitted; the SDK appends no app ID to an explicit value.
+`target` defaults to `'browser'`. A selected nonbrowser target adds the app's
+explicit `nativeResources` to `files`, without adding those native-only paths
+to `browserDocuments`. The optional normalized `nativeResources` record is
+returned when authored. This inspection copies or executes no resources.
+
+`output` is the selected workspace-relative final package directory. An explicit
+operation `outputDirectory` wins. Otherwise, a nonbrowser target with a nonempty
+native include list uses `dist/.native/<target>/<app-id>`; the app's saved browser
+destination remains separate. Browser selection, omitted native resources and
+an empty native include list use the app's saved `outputDirectory` or
+`dist/<app-id>`. The SDK appends no app ID to an explicit destination. See
+[native-only application resources](protocols.md#native-only-application-resources).
 
 ### Availability and normalization
 
@@ -881,9 +894,10 @@ console.log(normalizeRelativePath('apps/example/index.html'));
 
 ### Overview
 
-Builds one complete browser application release through the low-level packager
-API. It does not run tests or checks automatically; verification occurs only
-when explicitly requested or when required for this selected release output.
+Builds one complete selected application release through the low-level packager
+API, with browser selection by default. It does not run tests or checks
+automatically; verification occurs only when explicitly requested or when
+required for this selected release output.
 
 ### Signature and result
 
@@ -898,6 +912,21 @@ The package preserves the complete selected content, applying the documented
 asset-version and enabled browser-PWA transformations to resource references.
 Malformed configuration or descriptors fail while preserving the prior output.
 
+`target` defaults to `'browser'`; supported target names are `browser`,
+`portable`, `windows-x64`, `linux-x64`, `linux-arm64` and `android-arm64`.
+A nonbrowser target adds the app's explicit `nativeResources` selection and
+sets the effective `browserPwa` value to `false`. It does not compile or launch
+that platform. Browser calls preserve the existing `browserPwa` default and
+explicit setting. The app adapter's `buildArcanePackage()` context receives
+the actual `target` and effective `browserPwa` alongside its existing fields.
+`copyBase()` retains the browser/shared selection; native-only resources are
+copied afterward, outside browser rewriting and PWA processing.
+
+`moduleFormat` controls browser module representation independently of `target`.
+In particular, `moduleFormat:'native'` alone remains a browser package and does
+not add native resources. The complete selection and separate-output rules are
+documented under [native-only application resources](protocols.md#native-only-application-resources).
+
 `moduleFormat` defaults to `'import-map'`, preserving the ordinary browser
 package. Select `'native'` to resolve saved document import maps into native
 module URLs in the package stage and emit executable inline scripts as external
@@ -938,8 +967,8 @@ manifest or an operating-system launcher. Native-mode dry runs report selected
 input files; generated script/context files are included in the completed
 package's full returned inventory.
 
-The app's optional schema-1 `outputDirectory` selects the final
-workspace-relative destination. For example, `"ai"` emits directly into
+For browser selection, the app's optional schema-1 `outputDirectory` selects the
+final workspace-relative destination. For example, `"ai"` emits directly into
 `<workspace>/ai`; omission retains `dist/<app-id>`. The selected directory is
 wholly replaced through the existing staged swap, not merged. Changing the
 destination preserves the former output and siblings. Conflicting source,
@@ -947,6 +976,13 @@ selected input, or required control paths fail before output writes. Source
 layout, app identity, OPFS scope, and internal package paths remain unchanged.
 See [app-selected package output](protocols.md#app-selected-package-output).
 
+For a nonbrowser target with a nonempty native include list, the default is
+instead `dist/.native/<target>/<app-id>`, preserving a separately emitted browser
+output even when its saved destination is custom. An explicit operation
+`outputDirectory` still wins; choose a dedicated destination because packaging
+replaces that selected directory. Omitted or empty native resources retain the
+existing destination rules.
+
 Root app files retain their paths at the output root; explicitly nested apps
 retain their `apps/<id>/` paths. Shared files retain their configured route
 destinations. When the selected content supplies no root `index.html`, the SDK
@@ -1147,9 +1183,15 @@ console.log(validateAppBundlePath('payload/apps/example/index.html'));
 
 Validates one schema-1 packager app configuration and its relationship to the root config.
 
-Optional `outputDirectory` is the final workspace-relative package directory;
-omission preserves `dist/<app-id>`. It is an app package field, not a change to
-the root configuration's `distRoot` or the schema-2 app identity. Packaging
+Optional `nativeResources` contains a required literal-path `include` array
+(which may be empty) and optional `exclude` array (default `[]`). It selects
+additional app-owned resources only for a nonbrowser packaging target. Ordinary
+`include`, `exclude`, shared routes and document selection remain unchanged.
+
+Optional `outputDirectory` is the saved workspace-relative browser package
+directory; omission preserves `dist/<app-id>`. Nonempty native selection uses
+the separate target-selected default described above. It is an app package
+field, not a change to the root configuration's `distRoot` or the schema-2 app identity. Packaging
 reports conflicting output/input selections with `ARCANE_PACKAGE_INVALID`
 before output writes. Authored-descriptor comparison treats the destination
 as package-local, and descriptor refresh preserves the existing setting.
@@ -1216,7 +1258,8 @@ async function usevalidateRootConfig(...arguments_) {
 
 ### Overview
 
-Authenticates one existing browser app release through the low-level packager API.
+Reads one existing application release and compares its complete file inventory
+with its release manifest through the low-level packager API.
 
 ### Signature and result
 
@@ -1228,6 +1271,9 @@ Import it from `arcane-os` or `arcane-os/packager`. The signature above states w
 
 Optional `outputDirectory` selects the same workspace-relative override accepted
 by `packageApp`, without changing the app's saved destination.
+For a target-selected native input release, pass the returned `release.output`
+as this override. `verifyApp` has no target option and does not infer the native
+directory or execute the application, its services or a platform host.
 
 ### Availability and normalization
 
@@ -1238,9 +1284,13 @@ by `packageApp`, without changing the app's saved destination.
 ```javascript
 import {verifyApp} from 'arcane-os';
 
-async function useverifyApp(...arguments_) {
-    return verifyApp(...arguments_);
-}
+// release is the result of packageApp() for this app and workspace.
+const inspected = await verifyApp({
+    workspaceRoot,
+    appId: 'moon-dashboard',
+    outputDirectory: release.output
+});
+console.log(inspected.files);
 ```
 
 ## verifyAppReleaseBundle()
@@ -2210,6 +2260,13 @@ omitted and an authored empty list stays `[]`, so projection preserves automatic
 discovery versus entry-only selection. See
 [application document selection](protocols.md#application-document-selection).
 
+Optional `package.nativeResources` becomes top-level `nativeResources`.
+Omission remains omitted, an empty include remains `[]`, and an omitted exclude
+becomes `[]`. Package-only descriptor synthesis preserves the same selection.
+This is a packaging contract; `projectNativeDescriptor()` keeps its existing
+registry shape and ordinary include list. See
+[native-only application resources](protocols.md#native-only-application-resources).
+
 ### Signature and result
 
 ```text
@@ -4336,7 +4393,17 @@ console.log(validation.sdkInstallation?.packageVersion);
 
 ### Overview
 
-Builds and retained-verifies one explicitly selected native target through one paired provider.
+Builds one explicitly selected target through its adapter. A paired native
+builder packages the selected app and its explicit bundled-app closure, then
+passes those complete releases to the provider. Provider verification and host
+launch remain separate operations.
+
+The selected target reaches each app's packager, so every app's own
+`nativeResources` and separate native input directory apply consistently to
+both copying and output-overlap calculations. The provider receives the actual
+release roots, manifests and complete file readers. An explicit `nativeBuilder`
+retains its existing identity and contract. See
+[portable Core packaging](core-native-packaging.md#native-only-application-resources).
 
 ### Signature and result
 
@@ -4632,8 +4699,10 @@ described by `packageApp()`.
 The same low-level operation resolves the app's optional `outputDirectory`;
 there is no separate high-level destination override. `release.outputRoot`
 names the resulting complete release directory, with omitted configuration
-retaining `dist/<app-id>`. Browser preview, bundle creation, and native
-browser-content input use that selected root.
+retaining `dist/<app-id>`. Browser preview and bundle creation use that selected
+root. This ordinary package operation retains browser selection; paired native
+assembly through `buildApplication()` separately passes its actual target and
+applies each app's native-resource output selection.
 
 Packaging does not automatically run tests or checks. Verification occurs only
 when explicitly requested or when required for the selected release output.
@@ -6505,8 +6574,8 @@ console.log(CORE_READY_EVENTS.includes('core.ready')); // true
 ### Overview
 
 Describes the public fields for request, response, event, single-request
-cancellation and all-request cancellation frames. These are wire descriptions,
-not application validation or method admission.
+cancellation, all-request cancellation and `runtime.replay` control frames.
+These are wire descriptions, not application validation or method admission.
 
 ### Value and import
 
@@ -6640,11 +6709,11 @@ the client.
 ### Signature and result
 
 ```text
-createCoreClient({global=globalThis, transport=null, eventOwner=arcaneEvents, eventOwnerReady, autoConnect=true, onError}={})
+createCoreClient({global=globalThis, transport=null, eventOwner=arcaneEvents, eventOwnerReady, autoConnect=true, replayRuntimeState=false, onError}={})
 ```
 
 Import it from `arcane-os/core/client`. The result exposes `invoke`, `receive`,
-`connect`, `close`, `cancelAll`, `events`, `eventsReady`, `runtime.current()`,
+`connect`, `close`, `failTransport`, `cancelAll`, `events`, `eventsReady`, `runtime.current()`,
 `uuid`, `protocol` and `Error`. A supplied transport must provide callable
 `send(frame)`; an invalid transport stays disconnected and reports
 `ARCANE_TRANSPORT_INVALID`. Optional `subscribe(receive)` may return its cleanup
@@ -6656,6 +6725,21 @@ its still-pending request; a failure arriving after response, cancellation or
 timeout reaches `onError`. Deferred event-owner connection preserves the FIFO
 order of queued frames and subscription actions, including reentrant delivery.
 
+`replayRuntimeState:true` sends one observed `runtime.replay` control after the
+receive listener and `transport.ready` are established, without delaying page
+startup. The default is `false`; select replay only with a supporting host.
+Repeated connection calls do not repeat that control, and send failures reach
+`onError`. The host replays actual dispatcher and service state without
+restarting services; transport, Core and service readiness remain distinct.
+
+`failTransport(error)` ends the client after an actual terminal transport
+failure. Pending RPCs and WebKit acknowledgements reject with the complete
+`CoreError`, future invocations reject with that failure, and `onError` observes
+it once. The client releases its owned listeners, callbacks and timers without
+sending cancellation frames to the failed transport. The first terminal failure
+returns `true`; an already closed client returns `false`. Ordinary `close()`
+retains its separate cancellation behavior.
+
 ### Availability and normalization
 
 **Browser and native WebView JavaScript hosts.** Built-in transports select
@@ -6729,8 +6813,8 @@ client.close();
 ### Overview
 
 Installs one synchronous `globalThis.Arcane` facade and native
-`__arcaneReceive` callback. Repeated installation returns the same client for
-that global lifetime.
+`__arcaneReceive` and `__arcaneTransportFailed` callbacks. Repeated installation
+returns the same client for that global lifetime.
 
 ### Signature and result
 
@@ -6742,6 +6826,12 @@ Import it from `arcane-os/core/client`. The returned client is the same contract
 as `createCoreClient()`. Closing it releases subscriptions, native callbacks,
 timers and pending renderer requests; it does not kill Core.
 
+`__arcaneTransportFailed(error)` delegates actual terminal host failures to
+`client.failTransport(error)`. Closing or failing restores previous facade and
+callback globals only while the installation still owns them, preserving later
+replacements. `getInstalledCoreClient()` returns `null` after release, including
+before an installed terminal failure reaches `onError`.
+
 ### Availability and normalization
 
 **Browser and native WebView JavaScript hosts.** Installation makes synchronous
@@ -6761,6 +6851,41 @@ try {
 }
 ```
 
+## getInstalledCoreClient()
+
+### Overview
+
+Reads the existing live SDK-installed client without installing, connecting or
+replacing a facade. Applications use this accessor instead of private fields.
+
+### Signature and result
+
+```text
+getInstalledCoreClient(global=globalThis)
+```
+
+Import it from `arcane-os/core/client`. It returns the exact client installed in
+the selected global, including a classic document-created installation, or
+`null` when no live SDK installation exists. A foreign `Arcane` facade does not
+constitute an SDK installation. Close and terminal failure release the
+installation before subsequent reads.
+
+### Availability and normalization
+
+**Browser and native WebView JavaScript hosts.** This synchronous read changes
+no globals and starts no service, transport or model. The returned client's
+`runtime.current()` describes transport state; service readiness remains with
+its authoritative owner. See [Core browser client](core-client.md).
+
+### Example
+
+```javascript
+import {getInstalledCoreClient} from 'arcane-os/core/client';
+
+const client = getInstalledCoreClient();
+console.log(client ? client.runtime.current() : 'No SDK client is installed.');
+```
+
 ## createCoreClassicSource()
 
 ### Overview
@@ -6771,13 +6896,17 @@ client and contracts. It creates no copied client implementation or bundler.
 ### Signature and result
 
 ```text
-async createCoreClassicSource({eventOwnerModuleURL}={})
+async createCoreClassicSource({eventOwnerModuleURL,replayRuntimeState=false}={})
 ```
 
 Import it from `arcane-os/core/classic-source`. Supply the actual served URL for
 the selected SDK event-manager module. The promise resolves to the complete
 classic-script source.
 
+Optional `replayRuntimeState:true` forwards the current runtime-replay selection
+to the installed client. Omission retains the existing no-replay behavior; use
+`true` only when the composing host supports `runtime.replay`.
+
 ### Availability and normalization
 
 **Node; generated source runs in browser and native WebView renderers.** The
@@ -6821,6 +6950,11 @@ Shutdown stops admission, waits accepted responses, then runs each service's
 startup, drain and dispose in order while independent services close
 concurrently.
 
+The `runtime.replay` control publishes current dispatcher and service state
+without restarting services. Its snapshot preserves complete service errors
+and active request state; see [runtime replay](core-runtime.md#state-and-frames)
+for authoritative readiness and reentrant lifecycle ordering.
+
 ### Availability and normalization
 
 **Node on Windows, Linux and macOS native hosts; Android requires its native host
@@ -9419,3 +9553,8 @@ const cancelled = normalizeAIRequestAbort(new DOMException('Cancelled', 'AbortEr
 ## Data export subpaths
 
 The package also exposes eight JSON Schemas (including `arcane-os/schemas/event-stack.json`) and its package manifest. These are data contracts, not callable JavaScript members. See [schema contracts](../architecture.md) and the files under `schemas/`.
+
+`arcane-os/schemas/arcane-app.json` describes schema-2 `package.nativeResources`;
+`arcane-os/schemas/arcane-package.json` describes the projected schema-1
+`nativeResources`. Both use the existing literal application-relative path
+contract. See [native-only application resources](protocols.md#native-only-application-resources).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.55.0",
+  "version": "0.57.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -39,6 +39,7 @@
     "./speech-playback": "./runtime/arcane/modules/SpeechPlayback.js",
     "./speech-text": "./browser-runtime/speech-text.mjs",
     "./ai/browser-wasm": "./browser-runtime/ai/browser-wasm.mjs",
+    "./ai/core-local": "./browser-runtime/ai/core-local.mjs",
     "./ai/browser-decisions": "./browser-runtime/ai/browser-decisions.mjs",
     "./ai/tool-text-stream": "./browser-runtime/ai/tool-text-stream.mjs",
     "./ai/twin-cloud": "./browser-runtime/ai/twin-cloud.mjs",
@@ -49,12 +50,15 @@
     "./native": "./src/native-plan.mjs",
     "./native-provider": "./src/native-provider-loader.mjs",
     "./native/portable-provider": "./src/native/portable-provider.mjs",
+    "./native/windows-provider": "./src/native/windows-provider.mjs",
     "./core/client": "./browser-runtime/core/client.mjs",
     "./core/contracts": "./browser-runtime/core/contracts.mjs",
     "./core/classic-source": "./src/core-classic-source.mjs",
     "./core/runtime": "./src/core/runtime.mjs",
     "./core/stdio": "./src/core/stdio.mjs",
     "./core/host": "./src/core/host.mjs",
+    "./core/local-ai": "./src/core/services/local-ai.mjs",
+    "./local-ai": "./src/local-ai/install.mjs",
     "./integrated-provider": "./src/integrated-provider-loader.mjs",
     "./packager": "./src/packager/core.mjs",
     "./release-bundle": "./src/release-bundle.mjs",

package/runtime/arcane/modules/LocalAIReadiness.js

@@ -555,7 +555,9 @@ async function probeRequiredServices({
                         arcane,
                         requirements.llm.model
                     )
-                    :unavailableBrowserOllama()
+                    :is.function(arcane?.localAI?.status)
+                        ?probeNativeOllama(arcane,requirements.llm.model)
+                        :unavailableBrowserOllama()
             :null,
         requiresSpeech
             ?mode==='native'