arcane-os 0.88.1 → 0.90.0

package/docs/reference/core-client.md

@@ -161,6 +161,65 @@ pre-aborted signal sends no transcription request; an in-flight abort sends
 service owns interruption and release of its actual engine operation.
 Its optional request observer uses the same pre-dispatch correlation contract.
 
+## Current-window state
+
+`Arcane.window.state({signal}?)` reads the native window hosting the calling
+document. `Arcane.window.setState({state}, {signal}?)` selects `normal`,
+`maximized`, or `fullscreen` for that same window. Both use the existing
+request lifetime and return `{platform:'windows', supported:true, state}`.
+The observed `state` can also be `minimized`; minimize remains a native window
+control rather than a selectable state in this operation.
+
+```js
+async function selectObservatoryWindow(state) {
+    const result=await Arcane.window.setState({state});
+    console.log('Observatory window state:',result.state);
+}
+```
+
+Call this operation when the application's own setting or user action selects
+a state. Initial state belongs to the descriptor's optional
+[`native.window.state`](core-native-packaging.md#initial-native-window-size)
+field. Saved Settings, their loading and the choice to persist a state remain
+application-owned; the SDK adds no saved-state store or page-startup barrier.
+
+The Windows host uses ordinary native normal/maximized states. Fullscreen
+removes the window frame and occupies the selected monitor's full bounds,
+including its taskbar area. It retains the preceding normal bounds and frame
+controls for restoration. Selecting normal restores them; selecting maximized
+restores them before maximizing. This is native window fullscreen, separate
+from the browser Fullscreen API. It does not select TopMost, request foreground
+activation, change the profile/origin or restart Core. A minimized fullscreen
+window reports `minimized` until restored or another state is selected.
+
+Visible transitions use a temporary native callback confined to this window's
+UI thread and synchronous operation. It prevents activation of this window and
+focus assignment to it or its descendants, then releases the callback. Other
+windows and ordinary input remain untouched. Hidden initial configuration and
+already-selected states allocate no callback; the application's ordinary first
+show keeps its existing startup behavior. State reads observe the native
+minimized/maximized state, rather than merely echoing the requested selection.
+
+Malformed selections reject with `INVALID_ARGUMENT`; native operation failures
+reject with `ARCANE_WINDOW_STATE_FAILED`. Complete native error/cause fields
+remain available, with `details.requested`, `details.previous` and
+`details.actual` describing the attempted selection and observed state. A
+partial native change is observable rather than rolled back. Cancellation
+suppresses late responses and does not undo a change the host already applied.
+If native callback cleanup fails, it stops preventing activation immediately,
+its handle remains owned, and the failure is returned. Simultaneous mutation and
+cleanup failures retain both original errors. The owning window makes another
+cleanup attempt during its normal close and reports any remaining failure.
+State changes survive document navigation, while each response remains
+correlated to its originating document. There is no state-change event in this
+contract; `state()` reads the current native state when requested.
+
+These methods require the matching Windows host executable. The current macOS,
+Linux and Android hosts have no implementation of these operations; their
+actual unavailable-method errors remain observable. Ordinary browsers have no
+native window transport. The facade supplies no browser or other-host fallback,
+and importing it does not add support to an older native executable.
+
 ## Current-window theme
 
 `Arcane.window.setTheme(presentation, {signal}?)` changes only the window

package/docs/reference/core-native-packaging.md

@@ -149,6 +149,37 @@ same owner with an origin-root URL, including on nested pages. It does not creat
 a second event implementation. A plain file-URL launch without this host mapping
 is not the native serving contract. No host is launched during packaging.
 
+## App-owned runtime entry
+
+The generated `runtime/arcane-core.mjs` also accepts
+`--arcane-app-entry <app-relative-module>`. This explicit mode imports the
+selected file from the artifact's `app/` directory before ordinary launch-context
+or service initialization. It preserves the complete original `process.argv`
+and converts the native path to a file URL without treating filename characters
+as URL query or fragment syntax. Missing/empty selections and actual import
+failures propagate; there is no fallback to ordinary Core.
+
+Use the existing Windows `runtime/ArcaneCore.exe` with that flag and module path
+directly. On macOS, use bundled `runtime/node` with `runtime/arcane-core.mjs`
+followed by the flag and module path. Portable payloads use the host's supported
+Node executable with that same generated entry. The macOS artifact root is its
+`.app/Contents/Resources` directory. This mode needs no new executable, SEA
+loader, GUI launcher, or copied runtime.
+
+The app includes the module and its complete source closure through
+[`package.nativeResources`](#native-only-application-resources). The imported
+entry starts its own top-level work, not an `import.meta.main`-guarded entry or
+an automatically invoked export. It owns any explicit launch-context read,
+application services, MCP tools, signals and shutdown. No ordinary Core host,
+shared-host bridge, manifest services, model startup or Core pipe framing is
+started by this branch. Static SDK definition imports remain available; the
+ordinary parallel service imports and host lifetime stay unchanged when the
+flag is absent.
+
+For complete client command arrays, optional `--arcane-launch-config` handling,
+and MCP STDIO lifetime ownership, see
+[launch from a native package](mcp-stdio.md#launch-from-a-native-package).
+
 ## Explicit application services
 
 For the ordinary SDK build command, select native service modules in the
@@ -370,6 +401,11 @@ or service. Availability of a particular engine belongs to the selected
 local-AI installer and service; a generic ONNX runtime is not a speech model.
 
 Selected `onnx` bundles its complete managed `onnxruntime-node` dependency tree.
+For the SDK-selected Windows x64 ONNX `1.30.0` distribution, that tree includes
+the corrected native libraries and its runtime record retains
+`nativeDistributionRevision: '1.30.0-directml-reshape-1'`. See
+[ONNX runtime preparation](local-ai.md#development) for selection,
+release-asset acquisition and existing-installation behavior.
 Its `modulePath` resolves against the artifact root just as a server runtime's
 `executable` does. Library/module records need no executable. The generated Core
 service exposes retained worker sessions through `onnx.load/run/unload/status`;
@@ -489,7 +525,7 @@ forced process termination.
 
 ### Initial native window size
 
-An application can select its initial client area and resizing behavior in
+An application can select its initial client area, resizing behavior and state in
 `arcane-app.json`, independently of its page layout:
 
 ```json
@@ -499,15 +535,17 @@ An application can select its initial client area and resizing behavior in
     "icon": "img/icon.png",
     "order": 100,
     "bundledApps": [],
-    "window": {"width": 1280, "height": 800, "resizable": true}
+    "window": {"width": 1280, "height": 800, "resizable": true, "state": "normal"}
   }
 }
 ```
 
 This is the `native` portion of the existing app descriptor. Each `window`
 member is optional. `width` and `height` are positive integral client dimensions
-in logical pixels at 96 DPI; `resizable` is a boolean. Omitting a member retains
-the host's existing choice, and omitting `window` preserves existing startup.
+in logical pixels at 96 DPI; `resizable` is a boolean. Optional `state` is
+`normal`, `maximized`, or `fullscreen`. These example dimensions are an explicit
+application choice, not SDK-wide defaults. Omitting a member retains the host's
+existing choice, and omitting `window` preserves existing startup.
 The native registry projection preserves the record; the browser package
 projection gains no window controls. Portable and Windows assembly copy the
 record to `arcane-native.json` as `window`, without changing page or service
@@ -517,16 +555,30 @@ The matching Windows host applies the dimensions once on initial load, using
 the display DPI and fitting the outer window within the selected monitor's
 usable work area. This fit does not impose a persistent maximum size. Explicit
 `resizable:false` uses a fixed frame and disables the maximize control; `true`
-permits ordinary resizing and maximizing. Later app/user resizing remains
-untouched. A composing launcher's `Load` handler runs after this initial sizing
-and can restore its own saved window state. The SDK adds no saved-bounds store.
+permits ordinary resizing and maximizing. The selected initial state is applied
+after this normal-window sizing, so those normal bounds remain available when
+returning from maximized or fullscreen. Fullscreen uses a borderless window at
+the selected monitor's full bounds, including the taskbar area, without setting
+TopMost or requesting activation. Returning to normal restores the retained
+normal bounds and original frame, minimize/maximize and control-box settings.
+Selecting maximized from fullscreen restores them before maximizing.
+
+Later app/user resizing remains untouched. A composing launcher's `Load` handler
+runs after the initial sizing and optional state selection. Applications can
+read or change their own window through
+[`Arcane.window.state()` and `setState({state})`](core-client.md#current-window-state).
+The application's saved Settings and their application remain application-owned;
+the SDK adds no saved-state or saved-bounds store and does not delay rendering
+for those settings. The window's profile, origin and Core lifetime are unchanged.
 
 Direct Windows host composition uses nullable `ArcaneHostOptions` members
-`InitialClientWidth`, `InitialClientHeight`, and `Resizable` with the same
-semantics. Older precompiled Windows hosts do not read these options; use the
+`InitialClientWidth`, `InitialClientHeight`, `Resizable`, and optional string
+`InitialWindowState` with the same semantics. Older precompiled Windows hosts
+do not read these options; use the
 matching SDK host archive when rebuilding an application. The portable record
 is available to platform adapters; this addition implements its Windows host
-behavior and leaves window sizing on other platforms unchanged.
+behavior and leaves window sizing/state on other platforms unchanged. The current
+other-platform hosts do not implement this state selection.
 
 ### Application icon and window colors
 

package/docs/reference/core-repositories.md

@@ -47,7 +47,7 @@ const status = await repository.status({signal});
 await repository.close();
 ```
 
-`createRepositoryWorkspace({name,directory,dataRoot,remote,branch,longPaths,gitIdentity,onEvent,run}={})`
+`createRepositoryWorkspace({name,directory,dataRoot,remote,remoteBase,branch,longPaths,cloneIdentity,gitIdentity,onEvent,run}={})`
 returns `{directory,open,status,configuration,pull,push,write,close,drain,dispose}`. The `directory`
 property is the absolute selected working path.
 
@@ -63,11 +63,19 @@ property is the absolute selected working path.
   `branch`, when supplied, is passed unchanged to Git's `clone --branch` option;
   otherwise Git selects the remote's default branch. Existing checkouts keep
   their own branch, remote, tracked files, untracked files and local changes.
+- Supplying `remoteBase` explicitly declares this initial-clone `remote` to be
+  a local filesystem locator. Its native absolute command argument is captured
+  during construction. Omission leaves Git's original string interpretation
+  unchanged. See [relative local repository locators](#relative-local-repository-locators).
 - Optional `longPaths` is a boolean for newly cloned Windows checkouts. Explicit
   `true` or `false` supplies `clone --config core.longpaths=<value>`, so Git
   writes that choice to the new repository before its first checkout. Omission
   leaves Git's configuration unchanged. The option does not rewrite an existing
   checkout, change a global setting, or alter non-Windows clone commands.
+- Optional `cloneIdentity:{name?,email?}` persists explicitly selected author
+  fields in a newly cloned repository's local Git configuration. Omitted fields
+  keep Git's ordinary inheritance; existing checkouts retain their configuration.
+  See [clone-local author selection](#clone-local-author-selection).
 - `onEvent` and optional `run` use the existing SDK process owner. The default
   adapter is `runProcess`; Git must be available on PATH. Credentials and
   authentication remain with Git and the native host. The SDK adds no download,
@@ -169,13 +177,13 @@ commands for an attached local branch, or three otherwise. Results are not a
 transaction with later work or external Git activity. The app owns any decision
 that the current checkout corresponds to its selected repository and branch.
 
-The optional `target:{remote,ref}` on `pull`, `push` and `write` selects that
-operation's Git destination. Both fields are nonempty strings representable by
+The optional `target:{remote,ref,remoteBase?}` on `pull`, `push` and `write` selects
+that operation's Git destination. `remote` and `ref` are nonempty strings representable by
 the native process transport. The SDK captures their exact strings when the
 call is accepted; later edits to the target object or UI selection cannot
 redirect queued or active work. Git owns ref parsing, URL interpretation,
 credentials, hooks and remote outcomes. This target is independent of the
-factory's `remote`/`branch`, which remain initial-clone inputs only.
+factory's `remote`/`remoteBase`/`branch`, which remain initial-clone inputs only.
 
 ```javascript
 const observed = await repository.configuration({signal});
@@ -204,6 +212,54 @@ observe, refresh, write and publish. See Git's [pull](https://git-scm.com/docs/g
 [push](https://git-scm.com/docs/git-push) and [configuration](https://git-scm.com/docs/git-config)
 contracts.
 
+### Relative local repository locators
+
+`remoteBase` is an explicit local-path choice, not a hint for a URL parser.
+With it, the SDK derives the Git remote argument using the host's native
+`path.resolve(remoteBase, remote)`. A relative base, including `''` for the
+current directory, is resolved once when a workspace/snapshot owner is
+constructed or a targeted operation is accepted. Later working-directory or
+options-object changes cannot redirect that accepted operation. Base text
+must be representable as a native filesystem path; invalid non-string, NUL or
+unpaired-surrogate input reports `TypeError` without changing the supplied text.
+
+Use the same selected absolute base for owners created at different times:
+
+```javascript
+import {createGitTextSnapshot} from 'arcane-os';
+import {createRepositoryWorkspace} from 'arcane-os/core/repositories';
+
+const remote = connection.locator; // Keep the original catalog string.
+const remoteBase = connection.localBaseDirectory; // App-selected absolute base.
+const repository = createRepositoryWorkspace({name: connection.name, remote, remoteBase});
+const snapshot = createGitTextSnapshot({
+    cacheDirectory: connection.cacheDirectory,
+    remote, remoteBase, ref: connection.ref, selectPath: applicationSelectPath
+});
+const target = {remote, remoteBase, ref: connection.ref};
+await repository.write({files: selectedFiles, message, target, signal});
+// This reader wants the newly published selection, so refresh after the write.
+await snapshot.refresh({signal});
+```
+
+The original locator and ref remain unchanged. Public targeted results and
+writer failure outcomes also retain the explicitly supplied original
+`remoteBase`, including its relative spelling or empty string; the derived
+absolute argument stays with the Git invocation. No catalog/configuration
+rewrite, directory change or extra Git command is introduced. The existing
+Git clone may save its supplied remote argument as its ordinary origin setting.
+
+Omit `remoteBase` for configured names such as `origin`, URLs, SCP-like addresses,
+remote-helper syntax, or any other string Git should interpret normally. With
+an explicit base, even `origin` means the local path under that base. The SDK
+does not infer intent from slashes, colons or platform path spelling. Factory
+`remoteBase` affects only cloning; an individual pull/push/write uses only its
+own `target.remoteBase`. Omitting `target` retains configured Git behavior.
+The public `repositoryPull` and `repositoryPush` functions accept the same
+target field and capture it before their first asynchronous status operation.
+Actual filesystem, Git, credential and remote failures retain their existing
+complete diagnostics; this option adds no fallback, retry or unborn-state rule.
+
 ## Git identity configuration
 
 ```javascript
@@ -304,8 +360,8 @@ Each supplied name/email becomes command-local `-c user.name=...` or
 `GIT_COMMITTER_*` fields. Those selected fields take precedence over inherited
 author/committer settings and environment values; omitted fields, dates and
 unrelated environment remain inherited. Git retains its ordinary commit
-identity formatting and may reject an unusable identity. The SDK changes
-neither `process.env` nor global/local Git files.
+identity formatting and may reject an unusable identity. This command-local
+selection changes neither `process.env` nor global/local Git files.
 
 `username` supplies only command-local `credential.username`. Git's existing
 credential helper and remote protocol still own actual authentication. A
@@ -322,6 +378,46 @@ fetch. Existing arguments, content, output, errors, queue and cancellation
 semantics remain unchanged. Other repository helpers and CLI cwd defaults keep
 their existing behavior.
 
+### Clone-local author selection
+
+`createRepositoryWorkspace` also accepts `cloneIdentity:{name?,email?}` when the
+application wants its explicit selection retained by a newly owned clone:
+
+```javascript
+const repository = createRepositoryWorkspace({
+    name: 'moon-cheese-dispatches',
+    remote: applicationConnection.remote,
+    cloneIdentity: {name: 'Moon Dispatcher', email: 'moon@example.invalid'}
+});
+await repository.open({signal});
+```
+
+Each supplied field becomes `clone --config user.name=<name>` or
+`clone --config user.email=<email>`. Git writes these choices to the new local
+configuration before the initial checkout, on every supported platform. This
+adds no separate configuration command or post-clone initialization. It applies
+whenever the owner's first preparing operation needs a clone, including `write`.
+
+The exact strings are captured during I/O-free construction. Empty strings are
+explicit values; omitted or `undefined` fields add no setting, preserving Git's
+global inheritance, includes and any template configuration. Later caller edits
+do not alter an accepted owner. Non-string fields, NUL and text that the native
+process transport cannot represent report `TypeError` instead of changing input.
+Git retains ordinary configuration precedence, author formatting and failures.
+
+An existing checkout is never reconfigured by `cloneIdentity`, even when it is
+supplied. Changing or omitting the selection on a later owner does not remove a
+previously stored local setting. This option changes no global configuration,
+credentials, username selection, branch or remote. A failed or cancelled clone
+retains its actual diagnostics and any partial directory for the caller.
+
+`gitIdentity` remains the separate command-local selection described above.
+When both options are supplied, `cloneIdentity` selects the new clone's saved
+name/email while `gitIdentity` controls the selected child commands and their
+author/committer environment. Application defaults and per-repository choices
+remain application-owned. Neither option identifies the authenticated GitHub
+account or establishes who submitted a historical record.
+
 ## Write, commit and push selected text
 
 ```javascript
@@ -394,8 +490,8 @@ Successful completion returns:
 
 Each output record retains complete stdout/stderr. `code` and the process
 termination `signal` are included when a completed process result is available.
-When supplied, `target:{remote,ref}` is included in the result or failure outcome
-with the original accepted strings.
+When supplied, `target:{remote,ref,remoteBase?}` is included in the result or
+failure outcome with the original accepted strings.
 An in-progress write also records its current `path` on a failure outcome.
 `writtenPaths` records successful filesystem writes in input order; `written`
 becomes true only after every requested write succeeds. The other booleans

package/docs/reference/git-text-snapshot.md

@@ -33,12 +33,27 @@ policy stable for the lifetime of its snapshot owner.
 
 ## API and lifecycle
 
-`createGitTextSnapshot({cacheDirectory,remote,ref,selectPath,gitIdentity,onEvent,run})`
+`createGitTextSnapshot({cacheDirectory,remote,remoteBase,ref,selectPath,gitIdentity,onEvent,run})`
 returns `{refresh,close,drain,dispose}`. `run` defaults to the SDK's existing
 `runProcess`; applications normally omit it. It is the same process adapter
 contract, not a second process supervisor. `onEvent` is the ordinary SDK event
 callback and follows its asynchronous completion/error contract.
 
+Optional `remoteBase` explicitly selects `remote` as a local filesystem locator.
+The owner derives its native absolute Git argument once during construction
+using `path.resolve(remoteBase, remote)`, independently of the cache location
+and later working-directory changes. A relative base is captured against the
+construction-time working directory; `''` explicitly selects that directory.
+The caller's original locator and options remain unchanged. Without this field,
+every existing Git remote string keeps its ordinary meaning; the SDK does not
+guess whether a name, URL, colon or slash describes a local path.
+
+Use the same app-selected absolute base for snapshot, workspace clone and each
+explicit pull/push/write target. Factory clone inputs do not become operation
+targets. See [relative local repository locators](core-repositories.md#relative-local-repository-locators)
+for the shared contract, original target outcomes and example. This option adds
+no I/O, remote probe, configuration change, retry or empty-remote success path.
+
 Optional `gitIdentity:{name?,email?,username?}` uses the shared
 [Git identity configuration contract](core-repositories.md#git-identity-configuration).
 Supplied strings are captured during construction and accompany every Git

package/docs/reference/inventory/package-api.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "sdkVersion": "0.87.0",
+  "sdkVersion": "0.89.0",
   "environment": {
     "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
     "minimumVersion": "22.23.2 for Node entrypoints",
@@ -94,7 +94,7 @@
       "summary": "Connects to one explicit running native window for background document inspection, viewport capture, targeted DOM actions, fixed keys and Normal-window client resizing.",
       "availability": "Node local IPC on Windows, Linux and macOS; the current window adapter is Windows WebView2, with other native adapters unavailable",
       "protocol": "arcane/1 app.control.status, app.control.inspect, app.control.capture, app.control.act, app.control.key and app.control.resize over the existing framed local connection. The window host selects native.launchContext.appControl.endpoint and preserves its existing Core child, origin, profile and lifetime; assembly requires a matching published Windows host asset.",
-      "normalization": "Returns endpoint, closed, status(options), inspect(parameters={},options), capture(parameters={},options), act(parameters,options), key(parameters,options), resize(parameters,options), and close(). Parameters pass unchanged; per-operation options preserve Core signal/timeout behavior. Status reports actual app/window/document readiness. Inspect returns complete selected DOM HTML/text and live control state with DOM-derived role/name hints, plus top-level viewport CSS dimensions/devicePixelRatio, documentHasFocus and focusPath through the active open-shadow branch; focus records are observations with null selectors, separate from the selected root's activeElement. Optional shadowPath on inspect and act is an ordered array of unique CSS host selectors through open shadow roots; selector resolves in the final root, with omitted/empty paths retaining top-level light DOM. Whole-shadow-root inspection returns complete innerHTML/textContent with null selector/state; nested shadow-host descriptors provide their full path. Frames remain descriptors and closed roots are unavailable. Capture returns mimeType image/png, complete base64 data, documentGeneration and URL for the rendered viewport. Act requires documentGeneration and one CSS selector with click, exact-string fill, exact-value select or absolute-offset scroll. Key requires documentGeneration and Tab, Enter or Space; shiftKey:true is supported only for Tab. One keyboard owner keeps each press/release pair ordered at the selected WebView's current focus. An attempted press owns a matching release even after cancellation, navigation or failure; no failed or ambiguous press is replayed. Generation checks bracket native input without atomic document binding. Resize accepts positive integral native client width/height supported by WinForms and optional documentGeneration, changes only a Normal window's ClientSize, and returns immediate previous/actual native dimensions plus the later observed CSS viewport. Native and CSS snapshots are not atomic; platform constraints may change actual dimensions. Restoration is an explicit resize using the operation's previous native dimensions; unsupported window states fail before mutation. The native document marker prevents queued DOM actions crossing replacement; cancellation before dispatch prevents execution while dispatched work is observed through completion without retry or reversal, including owned key release. Partial results remain in actual errors and complete later responses remain in host diagnostics after cancellation or disconnection. Dispatch completion does not establish application handler completion or a successful business action. close() cancels only this connection, never the application or Core. No launch, automatic reconnect, desktop activation, global input or public arbitrary evaluator. CLI inspection accepts either --selector or a complete --request JSON object; act, key and resize forward their complete --request parameter objects. See native-app-control.md for complete result fields, CLI and platform scope."
+      "normalization": "Returns endpoint, closed, status(options), inspect(parameters={},options), capture(parameters={},options), act(parameters,options), key(parameters,options), resize(parameters,options), and close(). Parameters pass unchanged; per-operation options preserve Core signal/timeout behavior. Status reports actual app/window/document readiness and window state Normal, Maximized, Minimized or Fullscreen. Inspect returns complete selected DOM HTML/text and live control state with DOM-derived role/name hints, plus top-level viewport CSS dimensions/devicePixelRatio, documentHasFocus and focusPath through the active open-shadow branch; focus records are observations with null selectors, separate from the selected root's activeElement. Optional shadowPath on inspect and act is an ordered array of unique CSS host selectors through open shadow roots; selector resolves in the final root, with omitted/empty paths retaining top-level light DOM. Whole-shadow-root inspection returns complete innerHTML/textContent with null selector/state; nested shadow-host descriptors provide their full path. Frames remain descriptors and closed roots are unavailable. Capture returns mimeType image/png, complete base64 data, documentGeneration and URL for the rendered viewport. Act requires documentGeneration and one CSS selector with click, exact-string fill, exact-value select or absolute-offset scroll. Key requires documentGeneration and Tab, Enter, Space or Escape; shiftKey:true is supported only for Tab. One keyboard owner keeps each press/release pair ordered at the selected WebView's current focus. An attempted press owns a matching release even after cancellation, navigation or failure; no failed or ambiguous press is replayed. Generation checks bracket native input without atomic document binding. Resize accepts positive integral native client width/height supported by WinForms and optional documentGeneration, changes only a Normal window's ClientSize, and returns immediate previous/actual native dimensions plus the later observed CSS viewport. Native and CSS snapshots are not atomic; platform constraints may change actual dimensions. Restoration is an explicit resize using the operation's previous native dimensions; Maximized, Minimized and Fullscreen states fail before size mutation. The native document marker prevents queued DOM actions crossing replacement; cancellation before dispatch prevents execution while dispatched work is observed through completion without retry or reversal, including owned key release. Partial results remain in actual errors and complete later responses remain in host diagnostics after cancellation or disconnection. Dispatch completion does not establish application handler completion or a successful business action. close() cancels only this connection, never the application or Core. No launch, automatic reconnect, desktop activation, global input or public arbitrary evaluator. CLI inspection accepts either --selector or a complete --request JSON object; act, key and resize forward their complete --request parameter objects. See native-app-control.md for complete result fields, CLI and platform scope."
     },
     {
       "id": "local-ai-execution-devices:createExecutionDeviceCatalog",
@@ -311,14 +311,14 @@
       "name": "createRepositoryWorkspace",
       "displayName": "createRepositoryWorkspace()",
       "kind": "function",
-      "signature": "createRepositoryWorkspace({name,directory,dataRoot,remote,branch,longPaths,gitIdentity,onEvent,run=runProcess}={})",
+      "signature": "createRepositoryWorkspace({name,directory,dataRoot,remote,remoteBase,branch,longPaths,cloneIdentity,gitIdentity,onEvent,run=runProcess}={})",
       "entrypoints": ["arcane-os/core/repositories"],
       "primaryImport": "arcane-os/core/repositories",
       "group": "Native repository workspaces",
       "summary": "Owns one selected native working checkout with ArcaneData/Repos defaults and existing Git/process lifecycle.",
       "availability": "Node with Git on Windows, Linux and macOS; Android requires host process adaptation",
       "protocol": "Git working repository and SDK process adapter",
-      "normalization": "Returns directory, open, status, configuration, pull, push, write and identical close/drain/dispose hooks. Only missing or empty destinations clone; existing roots are preserved. Optional longPaths captures a boolean: explicit Windows true/false supplies clone-local core.longpaths before the first checkout, persisting only in the new repository under ordinary Git configuration precedence. Omission preserves configuration; existing repositories and non-Windows clone commands remain unchanged. No global setting or migration. configuration observes the existing root, symbolic HEAD, origin URL/pushURL arrays and branch remote/merge/upstream URL arrays without clone/init/fetch, preserving unset, empty and repeated values. Explicit paths remain selected. Same-directory operations serialize within the process; cancellation and shutdown join accepted process work. pull/push/write accept a captured target {remote,ref} for current-branch fast-forward pull or non-force current-HEAD selected-ref push; omission retains ordinary configured behavior. write snapshots exact text and paths, stages/commits only literal owned paths and preserves unrelated staged files and Git filters. Complete outputs and causal failures retain confirmed local/committed/pushed and uncertain outcomes plus the supplied target. Optional gitIdentity captures name/email/username for child Git operations only; omitted fields remain inherited and identity selection writes no config file."
+      "normalization": "Returns directory, open, status, configuration, pull, push, write and identical close/drain/dispose hooks. Only missing or empty destinations clone; existing roots are preserved. Optional factory remoteBase explicitly selects the initial-clone remote as a local filesystem locator and captures path.resolve(remoteBase, remote) once at construction. A relative base, including an empty string, uses the construction-time working directory. Only the Git argument is derived; the caller's original locator remains unchanged. Omission preserves every Git remote name, URL, SCP-like address and remote-helper string without guessed parsing. Optional longPaths captures a boolean: explicit Windows true/false supplies clone-local core.longpaths before the first checkout, persisting only in the new repository under ordinary Git configuration precedence. Omission preserves configuration; existing repositories and non-Windows clone commands remain unchanged. No global setting or migration. configuration observes the existing root, symbolic HEAD, origin URL/pushURL arrays and branch remote/merge/upstream URL arrays without clone/init/fetch, preserving unset, empty and repeated values. Explicit paths remain selected. Same-directory operations serialize within the process; cancellation and shutdown join accepted process work. pull/push/write accept a captured target {remote,ref,remoteBase?} for current-branch fast-forward pull or non-force current-HEAD selected-ref push; omission retains ordinary configured behavior. An operation's own remoteBase declares local-path intent and captures its native absolute argument once at acceptance, before queueing; factory remote/remoteBase/branch remain independent clone inputs. Targeted pull/push results and writer results/failure outcomes retain the original remote, ref and supplied remoteBase, including relative or empty base text. Unrepresentable base text reports TypeError without transformation. write snapshots exact text and paths, stages/commits only literal owned paths and preserves unrelated staged files and Git filters. Complete outputs and causal failures retain confirmed local/committed/pushed and uncertain outcomes plus the supplied target. Optional gitIdentity captures name/email/username for child Git operations only; omitted fields remain inherited and identity selection writes no config file. Optional cloneIdentity captures exact name/email strings and persists only supplied fields through clone --config before the first checkout on every supported platform. Empty strings are explicit; omitted or undefined fields preserve inherited/template configuration. Existing checkouts are never reconfigured. Unrepresentable process arguments fail honestly without transforming them. This option changes no global configuration or credentials and does not identify an authenticated account; command-local gitIdentity remains independent."
     },
     {
       "id": "core-repositories:readGitIdentity",
@@ -493,14 +493,14 @@
       "name": "createGitTextSnapshot",
       "displayName": "createGitTextSnapshot()",
       "kind": "function",
-      "signature": "createGitTextSnapshot({cacheDirectory,remote,ref,selectPath,gitIdentity,onEvent,run=runProcess}={})",
+      "signature": "createGitTextSnapshot({cacheDirectory,remote,remoteBase,ref,selectPath,gitIdentity,onEvent,run=runProcess}={})",
       "entrypoints": ["arcane-os"],
       "primaryImport": "arcane-os",
       "group": "Workspace, doctor, repository, and server",
       "summary": "Reads complete selected text from one fetched revision using a dedicated bare Git object cache and batched retrieval.",
       "availability": "Node with Git; Android requires a host supplying Git/process capability",
       "protocol": "Git tree and batched blob transport through the shared process owner",
-      "normalization": "Returns {refresh,close,drain,dispose}; refresh yields {revision,files:[{path,content}]}, shares concurrent work, reuses unchanged revisions, preserves exact UTF-8 text, isolates caller cancellation and drains accepted work. Optional gitIdentity captures name/email/username for child Git commands including bare init and fetch, without changing config files, payloads or shared acquisition lifetime. See git-text-snapshot.md."
+      "normalization": "Returns {refresh,close,drain,dispose}; refresh yields {revision,files:[{path,content}]}, shares concurrent work, reuses unchanged revisions, preserves exact UTF-8 text, isolates caller cancellation and drains accepted work. Optional remoteBase explicitly selects remote as a local filesystem locator and derives only its Git fetch argument through path.resolve(remoteBase, remote), once at construction independently of the cache location and later working-directory changes. A relative base, including an empty string, uses the construction-time working directory; original locator/options remain unchanged. Omission preserves every Git remote name, URL, SCP-like address and remote-helper string without guessed parsing. Unrepresentable base text reports TypeError without transformation; existing Git failures remain errors. Optional gitIdentity captures name/email/username for child Git commands including bare init and fetch, without changing config files, payloads or shared acquisition lifetime. See git-text-snapshot.md."
     },
     {
       "id": "diarization:createDiarization",
@@ -563,14 +563,14 @@
       "name": "createCoreLocalAIProvider",
       "displayName": "createCoreLocalAIProvider()",
       "kind": "function",
-      "signature": "createCoreLocalAIProvider({client,id='llama.cpp'}={})",
+      "signature": "createCoreLocalAIProvider({client,id='llama.cpp',prepareModel}={})",
       "entrypoints": ["arcane-os/ai/core-local"],
       "primaryImport": "arcane-os/ai/core-local",
       "group": "Core local AI",
       "summary": "Browser llama.cpp provider through an explicitly connected Core, with application-owned model selection and complete response streaming.",
       "availability": "Browser with an available Core local AI service; construction installs no runtime or model",
       "protocol": "arcane-ai-provider/2 LLM lifecycle over arcane/1",
-      "normalization": "Preserves complete payloads and original parsed chunks; waits for the exact requested model and cancels on observed readiness loss. Omitted client follows installation/replacement/retirement; explicit client including null stays fixed. Inspect reports load capability separately from loaded readiness; disposal releases only an actually retained selection through its captured client. Provider/2 role state reconciles at existing operation boundaries, not through an idle state subscription."
+      "normalization": "Preserves complete payloads and original parsed chunks; load waits for the exact requested model and inference cancels on observed readiness loss. Omitted client follows installation/replacement/retirement; explicit client including null stays fixed. Optional prepareModel({selection,signal,progress}) runs at load and returns assetProjectionId, resourcePaths, executionTarget and optional release; load({selection,signal,progress,assetProjectionId,resourcePaths,executionTarget}) lets defined direct fields override preparation, including an explicit null target. Preparation release is awaited on success, failure and cancellation, including late preparation results. Inspect reports managed preparation/load capability separately from readiness. Only the current successfully completed load accepts readiness and inference; failed same-name replacement cannot reuse prior readiness. status().execution forwards complete native execution diagnostics. Unload releases the last dispatched selection only while its owning connection remains current; disposal uses its captured client. Preparation alone creates no native release ownership. Provider/2 role state reconciles at existing operation boundaries, not through an idle state subscription."
     },
     {
       "id": "core-local-ai:createLocalAIService",
@@ -584,7 +584,7 @@
       "summary": "Composes selected native llama.cpp, Ollama and ONNX engines as a Core service with retained process/worker ownership and model lifecycle.",
       "availability": "Node with selected upstream runtime distributions or available configured system services",
       "protocol": "arcane/1 methods and events; llama.cpp OpenAI HTTP/SSE, Ollama native HTTP/NDJSON and ONNX tensor transport",
-      "normalization": "Application-owned runtime and model requirements; optional prepare supplies installed records during this service startup. Optional executionDevices supplies a borrowed catalog to ONNX; its supplying owner retains catalog disposal responsibility. onnx.load forwards executionPreference and executionTarget with existing model-path resolution, cancellation and omitted-target behavior. getONNXRuntime() returns the actual prepared ONNX owner for native composition after context.getService('local-ai'); callers reacquire after recovery and retain the acquired handle for cleanup. llama.status/models observe without starting or restarting an engine. Independent services, complete responses and exact owned-process cleanup remain unchanged."
+      "normalization": "Application-owned runtime and model requirements; optional prepare supplies installed records during this service startup. Optional executionDevices supplies a borrowed catalog to ONNX and llama.cpp; its supplying owner retains catalog disposal responsibility. onnx.load forwards executionPreference and executionTarget with existing model-path resolution, cancellation and omitted-target behavior. getONNXRuntime() returns the actual prepared ONNX owner for native composition after context.getService('local-ai'); callers reacquire after recovery and retain the acquired handle for cleanup. llama.load({model,assetProjectionId,resourcePaths,executionTarget}) retains resourcePaths.model from the existing model-assets owner through actual managed process exit. Omitted target retains the same model's selection or configured default; null requests the runtime default. Explicit Windows NVIDIA targets resolve this host's deviceId to its CUDA device identity; unsupported or unavailable selections report their actual failure without substitution. execution distinguishes requested/resolved/configured targets from observedTarget:null. Existing external listeners retain their model/device ownership and reject managed reconfiguration. llama.status/models observe without starting or restarting an engine. Independent services, complete responses and exact owned-process cleanup remain unchanged."
     },
     {
       "id": "core-local-ai:default",
@@ -609,10 +609,10 @@
       "entrypoints": ["arcane-os/local-ai"],
       "primaryImport": "arcane-os/local-ai",
       "group": "Core local AI",
-      "summary": "Reuses selected managed native runtimes or installs complete official llama.cpp/Ollama/image distributions, ONNX npm runtime trees or NeMo libraries.",
-      "availability": "Node; upstream platform and architecture assets determine runtime availability",
-      "protocol": "Official upstream release archives and selected ONNX/Koffi npm runtime installations",
-      "normalization": "Returns absolute runtime records, including image library/binding/variant/model metadata; shares matching installs, preserves libraries, reports failures without changing global PATH or services and prepares no model files"
+      "summary": "Reuses selected managed native runtimes or installs complete llama.cpp/Ollama/image distributions, ONNX npm runtime trees with selected SDK native libraries, or NeMo libraries.",
+      "availability": "Node; selected distribution platform and architecture assets determine runtime availability",
+      "protocol": "Upstream release archives and selected ONNX/Koffi npm installations; corrected Windows x64 ONNX native libraries from the installed SDK numeric release",
+      "normalization": "Returns absolute runtime records, including image library/binding/variant/model metadata; Windows x64 ONNX with no explicit URL and omitted version or 1.30.0 adds nativeDistributionRevision 1.30.0-directml-reshape-1, reuses that revision or prepares a fresh installation while preserving older trees; explicit URLs and other ONNX versions/platforms retain their upstream package path; shares matching installs, preserves libraries, reports failures without changing global PATH or services and prepares no model files"
     },
     {
       "id": "local-ai:bundleLocalAIRuntimes",
@@ -624,9 +624,9 @@
       "primaryImport": "arcane-os/local-ai",
       "group": "Core local AI",
       "summary": "Copies selected complete runtime distributions into a fresh native artifact staging root.",
-      "availability": "Node; supports bundling published upstream platform assets independently of the build host",
+      "availability": "Node; supports bundling selected published platform assets independently of the build host",
       "protocol": "Artifact-relative runtime/local-ai layout",
-      "normalization": "Returns {runtimes,files} with artifact-relative runtime/variant paths and complete inventory; image URL descriptors remain for post-launch preparation and external model working paths report portability incompatibility"
+      "normalization": "Returns {runtimes,files} with artifact-relative runtime/variant paths and complete inventory; corrected Windows x64 ONNX retains nativeDistributionRevision and complete native libraries while modulePath becomes artifact-relative; image URL descriptors remain for post-launch preparation and external model working paths report portability incompatibility"
     },
     {
       "id": "root:WS",
@@ -654,7 +654,7 @@
       "summary": "Explicit-load Laya and Julia-1 decisions with caller-selected precision, complete inputs and graph results.",
       "availability": "Browser module Workers and the selected Transformers.js backend; import/construction starts no model load",
       "protocol": "Caller-owned state/question/options rows; five-input decision graph; native Worker request/result lifecycle",
-      "normalization": "Full field tokenization, raw logits and unrounded softmax; dtype defaults to fp16 for Laya and fp32 for Julia, with explicit values forwarded unchanged. Optional existing SDK store routes the complete selected runtime entry and actual loader resources through fetchResource outside cloned Worker configuration. Each activation materializes unchanged entry source with JavaScript MIME and retains its original configured URL for later loads; its object URL is revoked after Worker termination. Stored mode disables competing model caches, preserves complete HTTP responses and joins runtime-entry/resource cleanup before outstanding calls settle. Runtime-entry HTTP failures retain error.response. Custom stored entries must support an object URL and changed import.meta.url; native absolute dependencies and custom factory imports outside upstream preloads remain browser-owned. Omission retains direct native module and upstream model loading; no decision-result persistence or precision fallback"
+      "normalization": "Full field tokenization, raw logits and unrounded softmax; dtype defaults to fp16 for Laya and fp32 for Julia, with explicit values forwarded unchanged. Optional existing SDK store routes actual loader resources through fetchResource outside cloned Worker configuration. By default stored activation also materializes the unchanged runtime entry as a JavaScript object URL, retains its configured URL for later loads and revokes the object URL after Worker termination. Explicit runtime.local:true instead imports same-deployment moduleUrl and wasmPaths.mjs/wasm directly, defaulting to ai/decisions-runtime installed by browserDecisions:true materialization; only those exact executable URLs bypass the model store. It disables upstream executable WASM caching/proxy and selects one WASM thread, preserving the requested inference backend. Stored mode disables competing model caches, preserves complete HTTP responses and joins resource cleanup before outstanding calls settle. Default runtime-entry HTTP failures retain error.response; custom stored entries must support an object URL and changed import.meta.url. Omission retains existing browser behavior; no decision-result persistence or precision fallback"
     },
     {
       "id": "root:acceptWebSocket",
@@ -1734,7 +1734,7 @@
       "name": "materializeInstalledSdkRuntime",
       "displayName": "materializeInstalledSdkRuntime()",
       "kind": "function",
-      "signature": "async materializeInstalledSdkRuntime({workspaceRoot,sdkPackageSource,workspaceOperationLease,signal,onEvent}={})",
+      "signature": "async materializeInstalledSdkRuntime({workspaceRoot,sdkPackageSource,browserDecisions=false,workspaceOperationLease,signal,onEvent}={})",
       "entrypoints": [
         "arcane-os"
       ],
@@ -1743,14 +1743,14 @@
       "summary": "Materializes the complete installed SDK runtime and browser runtime, then replaces semantic arcane.lock.json metadata from the actual installed dependency and package.",
       "availability": "Node",
       "protocol": "Installed SDK runtime materialization",
-      "normalization": "Complete installed runtime content and a mutable materialization result"
+      "normalization": "Complete installed runtime content and a mutable materialization result. Explicit browserDecisions:true acquires the upstream bundled Transformers.js 4.3.0 and matched ONNX Runtime 1.31.0-dev.20260914-8d85527a0 asyncify module/WASM plus licenses into arcane/sdk/ai/decisions-runtime before replacement. The optional workspaceRuntime.browserDecisions result contains directory, versions and filenames. Default false performs no optional acquisition. Progress counts completed files; signal, HTTP and observer failures abort/join acquisition and preserve the previous projection. Select the option on each refresh that should retain the closure; model/tokenizer data remain upstream/cache-owned"
     },
     {
       "id": "root:materializeWorkspaceRuntimeContent",
       "name": "materializeWorkspaceRuntimeContent",
       "displayName": "materializeWorkspaceRuntimeContent()",
       "kind": "function",
-      "signature": "async materializeWorkspaceRuntimeContent({workspaceRoot,runtimeRoot=path.join(getSdkRoot(), 'runtime'),browserRuntimeRoot=getSdkBrowserRuntimeRoot(),signal,onEvent}={})",
+      "signature": "async materializeWorkspaceRuntimeContent({workspaceRoot,runtimeRoot=path.join(getSdkRoot(), 'runtime'),browserRuntimeRoot=getSdkBrowserRuntimeRoot(),sdkVersion=SDK_VERSION,browserDecisions=false,signal,onEvent}={})",
       "entrypoints": [
         "arcane-os"
       ],
@@ -1759,7 +1759,7 @@
       "summary": "Replaces one workspace's complete projected runtime and browser-runtime content from selected source roots.",
       "availability": "Node",
       "protocol": "Workspace runtime materialization",
-      "normalization": "Complete workspace runtime content and a mutable materialization result"
+      "normalization": "Complete workspace runtime content and a mutable materialization result. browserDecisions:true adds the same explicit upstream browser executable acquisition as materializeInstalledSdkRuntime; the optional browserDecisions result contains directory, transformersVersion, onnxRuntimeVersion and files. Default false leaves acquisition disabled. Complete distribution content is copied without source rewriting, with cancellation/error cleanup before staged replacement and no model/tokenizer packaging"
     },
     {
       "id": "root:NATIVE_BUILD_PLAN_PROTOCOL",
@@ -2269,7 +2269,7 @@
       "summary": "Runs one fast-forward-only pull into the selected clean worktree, optionally from a captured remote/ref target.",
       "availability": "Node; network-assisted Git",
       "protocol": "Node ESM",
-      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+      "normalization": "Optional target {remote,ref,remoteBase?} is captured before the first asynchronous status operation. A supplied remoteBase declares local-path intent and derives only the Git remote argument using path.resolve(remoteBase, remote), once at acceptance; relative and empty bases use that working directory. Omitted remoteBase preserves Git remote names, URLs, SCP-like addresses and remote-helper strings unchanged. Targeted results retain original remote/ref/supplied remoteBase text and complete stdout/stderr alongside the existing pull result. Unrepresentable base text reports TypeError without transformation. Omitted target preserves configured pull behavior and result shape; clean-worktree, fast-forward-only, cancellation and actual Git error behavior remain unchanged."
     },
     {
       "id": "root:repositoryPush",
@@ -2285,7 +2285,7 @@
       "summary": "Pushes the attached branch through ordinary configured Git or an explicit captured current-HEAD destination without force.",
       "availability": "Node; network-assisted Git",
       "protocol": "Node ESM",
-      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+      "normalization": "Optional target {remote,ref,remoteBase?} is captured before the first asynchronous status operation. A supplied remoteBase declares local-path intent and derives only the Git remote argument using path.resolve(remoteBase, remote), once at acceptance; relative and empty bases use that working directory. Omitted remoteBase preserves Git remote names, URLs, SCP-like addresses and remote-helper strings unchanged. Targeted results retain original remote/ref/supplied remoteBase text and complete stdout/stderr alongside the existing push result. Unrepresentable base text reports TypeError without transformation. Omitted target preserves configured push behavior and result shape; attached-branch, non-force current-HEAD publication, cancellation and actual Git error behavior remain unchanged."
     },
     {
       "id": "root:repositoryStatus",
@@ -4360,7 +4360,7 @@
       "summary": "Projects a Core client into the established application-facing Arcane namespace.",
       "availability": "Browser and native WebView JavaScript hosts with a Core client",
       "protocol": "arcane/1 compatibility facade",
-      "normalization": "Routes namespace methods through client.invoke while retaining operation-specific parameters, correlation, streaming callbacks, timeouts and cancellation; window.setTheme(presentation,{signal}?) forwards the complete per-window backgroundColor/textColor record, with omitted fields unchanged and null reset, and returns the host's actual applied/unsupported result without changing system appearance"
+      "normalization": "Routes namespace methods through client.invoke while retaining operation-specific parameters, correlation, streaming callbacks, timeouts and cancellation; window.state({signal}?) reads the requesting window and window.setState({state},{signal}?) selects normal, maximized or fullscreen. The matching Windows host returns {platform:'windows',supported:true,state}, including observed minimized state, restores normal bounds/frame controls on leaving fullscreen and prevents activation/focus assignment during visible state transitions without changing TopMost, Core, origin or profile. Saved Settings remain application-owned; cancellation does not undo an applied change and unavailable hosts retain their actual errors without fallback. window.setTheme(presentation,{signal}?) forwards the complete per-window backgroundColor/textColor record, with omitted fields unchanged and null reset, and returns the host's actual applied/unsupported result without changing system appearance"
     },
     {
       "id": "core-client:installCoreClient",
@@ -4500,7 +4500,7 @@
       "summary": "Creates the SDK-owned provider that assembles one selected app and explicit services into a portable Core payload.",
       "availability": "Node; produces a portable payload rather than an executable host",
       "protocol": "arcane-native-builder/1 portable provider",
-      "normalization": "Preserves complete selected app and dependency releases; an explicit services selection overrides appDescriptor.native.services, otherwise the descriptor selection is used; optional appDescriptor.native.window carries positive integral logical client width/height and optional resizable into manifest.window with omitted fields preserved. Generated coreListener opt-in composes one passive model-observation service from the existing host.runtime and actual services exposing localai.status/image.status/decisions.status before listener binding, with absent owners null and renderer attachment separate. Ordinary stdio and sharedHost/headless behavior remains unchanged; no model creation, getService or readiness barrier. Reports executable:false and never substitutes for an unavailable platform host"
+      "normalization": "Preserves complete selected app and dependency releases; an explicit services selection overrides appDescriptor.native.services, otherwise the descriptor selection is used; optional appDescriptor.native.window carries positive integral logical client width/height, optional resizable and optional state normal/maximized/fullscreen into manifest.window with omitted fields preserved; the selected platform host owns the applied behavior. Generated coreListener opt-in composes one passive model-observation service from the existing host.runtime and actual services exposing localai.status/image.status/decisions.status before listener binding, with absent owners null and renderer attachment separate. Ordinary stdio and sharedHost/headless behavior remains unchanged; no model creation, getService or readiness barrier. Generated runtime/arcane-core.mjs accepts --arcane-app-entry <app-relative-module> through the host's supported Node executable. It imports the packaged app/ module's top-level work with complete process.argv unchanged and no automatic export call; the app owns launch-context reads, services, signals and shutdown. Include the entry and complete source closure through package.nativeResources. The flag skips ordinary Core startup; omission retains it. See mcp-stdio.md#launch-from-a-native-package and core-native-packaging.md#app-owned-runtime-entry. Reports executable:false and never substitutes for an unavailable platform host"
     },
     {
       "id": "native-portable-provider:arcaneNativeBuilderProvider",
@@ -4542,7 +4542,7 @@
       "summary": "Assembles selected application services and browser content with the SDK-owned Windows x64 WebView2 and SEA host.",
       "availability": "Node for assembly; Windows x64 with WebView2 Runtime for execution",
       "protocol": "arcane-native-builder/1 windows-x64 provider",
-      "normalization": "Uses a selected hostDirectory or the exact installed SDK version's numeric release asset; preserves complete payloads; app displayName plus .exe (app ID fallback) and matching .exe.config use Windows filename substitutions only; manifest.host.executable owns inventory, icon, verify and run while generic cache/Core names remain unchanged; native.icon PNG/ICO derives the copied executable and host.icon without an app compiler, while other formats retain assembly with native.icon.unsupported and executableIcon:false; the matching host loads the selected window/taskbar icon and handles window.setTheme with per-field applied/unsupported results; native.window selects initial 96-DPI logical client width/height and optional resizable through manifest.window, the matching host scales to actual DPI and fits initial placement to the usable screen while omitted fields and existing restored non-normal state remain unchanged; no saved-bounds subsystem is added and initial-fit logic is not reapplied during later resizing; run cancellation closes stdin and waits for host-owned graceful shutdown"
+      "normalization": "Uses a selected hostDirectory or the exact installed SDK version's numeric release asset; preserves complete payloads; app displayName plus .exe (app ID fallback) and matching .exe.config use Windows filename substitutions only; manifest.host.executable owns inventory, icon, verify and run while generic cache/Core names remain unchanged; native.icon PNG/ICO derives the copied executable and host.icon without an app compiler, while other formats retain assembly with native.icon.unsupported and executableIcon:false; the matching host loads the selected window/taskbar icon and handles window.setTheme with per-field applied/unsupported results; native.window selects initial 96-DPI logical client width/height, optional resizable and optional state normal/maximized/fullscreen through manifest.window. The matching host scales dimensions to actual DPI, fits initial placement to the usable screen and applies an explicit state afterward; omitted fields preserve existing host behavior. Fullscreen fills the selected monitor without a frame and retains normal bounds/frame controls for restoration. Requesting-window window.state/window.setState observe actual minimized/maximized state and prevent activation/focus assignment during visible transitions without selecting TopMost or changing Core, origin or profile. Saved Settings remain application-owned; no saved-bounds subsystem is added and initial-fit logic is not reapplied during later resizing; run cancellation closes stdin and waits for host-owned graceful shutdown. Packaged runtime/ArcaneCore.exe accepts --arcane-app-entry <app-relative-module> directly, without a script argument or GUI launcher; it imports the packaged app/ module's top-level work, preserves complete process.argv and invokes no export. Include the entry and complete source closure through package.nativeResources. The app owns launch-context reads, services, signals and shutdown; the flag skips ordinary Core startup, while omission preserves it. See mcp-stdio.md#launch-from-a-native-package and core-native-packaging.md#app-owned-runtime-entry"
     },
     {
       "id": "native-windows-provider:arcaneNativeBuilderProvider",