arcane-os 0.1.1 → 0.1.2

package/browser-runtime/ARCANE_SDK_BROWSER_RELEASE.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "builder": "arcane-sdk-browser-runtime-v1",
-  "sdkVersion": "0.1.1",
+  "sdkVersion": "0.1.2",
   "source": {
     "authority": "arcane-os-sdk",
     "repository": "https://github.com/TheWizardNexus/arcane-os-sdk.git",

package/docs/reference/README.md

@@ -27,6 +27,7 @@ high-level page links to the relevant deep section instead of repeating it.
 | Call `globalThis.Arcane` | [Arcane Core API](core/arcane-api.md) |
 | Subscribe to native events | [Arcane event reference](core/arcane-events.md) |
 | Use provider-neutral AI | [Arcane AI contracts](core/arcane-ai-contracts.md) |
+| Run a caller-authenticated local LLM in the browser | [Browser-WASM local AI](ai/browser-wasm.md) |
 | Use Arcane Ollama | [Arcane Ollama guide](arcane-ollama.md) |
 | Understand transports and protocol switching | [Protocol and host architecture](protocols.md) |
 | Run contract and behavior tests | [Behavioral testing](behavioral-testing.md) |
@@ -37,7 +38,7 @@ This repository contains two related, explicitly versioned surfaces:
 
 | Surface | Source identity | Meaning |
 | --- | --- | --- |
-| SDK and CLI | `arcane-os` `0.1.0` | The Node.js toolchain and package exports in this checkout. |
+| SDK and CLI | `arcane-os` `0.1.1` | The Node.js toolchain plus the browser-only `arcane-os/ai/browser-wasm` entrypoint in this checkout. |
 | Browser runtime | Arcane OS commit `567ad110bf57a1c2d4a3daa22ae93716cc5f4d7e`, bundle `0.8.12`, protocol `arcane/1` | The exact 155-file runtime snapshot shipped under `runtime/`. |
 | Core reference snapshot | Arcane OS commit `567ad110bf57a1c2d4a3daa22ae93716cc5f4d7e`, protocol `arcane/1` | The application-facing Core contract derived into `docs/reference/core/`. Canonical inventory and focused-member content was verified unchanged at Arcane OS `main` commit `13f3ce0ae34f77a3495331c8b4c30b1bb105f8ed`; SDK-local provenance, link, and package-boundary annotations are added explicitly. |
 
@@ -73,11 +74,13 @@ Public reference entries follow the established Arcane documentation model:
 
 ## Public runtime inventory
 
-The Node package exposes 158 semantic JavaScript records across 11 JavaScript
+The package exposes 163 semantic JavaScript records across 12 JavaScript
 entrypoints, plus eight JSON Schemas, its exact runtime manifest, and package
-metadata. The [machine-readable package inventory](inventory/package-api.json)
-and [SDK member reference](sdk-api.md) are checked bidirectionally against every
-declared JavaScript export.
+metadata. Ten entrypoints are Node.js control-plane surfaces,
+`arcane-os/event-manager` runs in Node and browsers, and
+`arcane-os/ai/browser-wasm` is browser-only. The [machine-readable package
+inventory](inventory/package-api.json) and [SDK member reference](sdk-api.md)
+are checked bidirectionally against every declared JavaScript export.
 
 The seven update-check records are explicit on-demand checks; they do not poll,
 download, install, or self-update.

package/docs/reference/ai/browser-wasm.md

@@ -0,0 +1,335 @@
+# Browser-WASM local AI
+
+Use this browser-only entrypoint when an application deliberately owns a local
+GGUF model authority and wants provider-neutral LLM lifecycle, chat, streaming,
+cancellation, and structural tool-call results without an Arcane Core host.
+For ordinary hosted applications, start with the [Arcane AI
+contracts](../core/arcane-ai-contracts.md) and `globalThis.Arcane.ai`. This
+page is the focused local-browser path beneath the normalized AI decision
+guide.
+
+The wiring example assumes a scaffolded or materialized Arcane application
+with SDK `0.1.1`'s authenticated runtime tree and 86-entry browser import map.
+`arcane/DBOPFS` is a managed browser-map specifier, not an npm package export.
+See [browser runtime delivery](../protocols.md#browser-runtime-delivery) before
+using the example in a custom host or bundler.
+
+```javascript
+import DBOPFS from 'arcane/DBOPFS';
+import {
+    createArcaneAI,
+    createBrowserModelSource,
+    createBrowserWasmLlmProvider,
+    createDbopfsModelStore
+} from 'arcane-os/ai/browser-wasm';
+
+const MODEL = Object.freeze({
+    id:'my-reviewed-model',
+    name:'model-q4.gguf',
+    immutableUrl:'https://models.example/revisions/4f7c/model-q4.gguf',
+    bytes:123456789,
+    sha256:'0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+    licenseSpdx:'Apache-2.0',
+    sourceRevision:'4f7c'
+});
+
+const dbopfs = globalThis.dbopfs || new DBOPFS({applicationId:'my-app'});
+await dbopfs.readyPromise;
+const source = createBrowserModelSource(MODEL);
+const store = createDbopfsModelStore({dbopfs});
+const provider = createBrowserWasmLlmProvider({source, store});
+const ai = createArcaneAI({provider, loadPolicy:'manual'});
+
+// Put this behind an explicit user action: it can download MODEL.bytes bytes.
+async function loadReviewedModel() {
+    return ai.load({threads:1, contextTokens:4096, gpuLayers:0});
+}
+```
+
+The browser-WASM runtime closure packages the authenticated
+`@wllama/wllama` `3.6.0` ESM and WebAssembly runtime plus the Wllama and
+llama.cpp MIT license texts. It
+packages no model weights, model catalog, CDN fallback, native provider, speech
+synthesis, or transcription. Callers supply the exact model authority. `bytes`
+is the expected positive byte length, not inline model data.
+
+## Lifecycle at a glance
+
+`createArcaneAI()` owns one LLM controller. Its default `loadPolicy` is
+`on-demand`; the first request may download and initialize the model. Use
+`manual` when a user action, resource review, or progress UI must precede load.
+
+| Operation | Result |
+| --- | --- |
+| `ai.status()` | Frozen `{llm: status}` wrapper. |
+| `ai.load(options)` | Flat LLM status after load. |
+| `ai.llm.chat(request)` / `ai.fetchRequest(request)` | Validated OpenAI-like completion. |
+| `ai.llm.stream(request)` | Frozen async-iterator handle with `result` and `cancel(reason)`. |
+| `ai.streamRequest(request)` | Consumes the stream and returns text or `{toolName: argumentJsonString}`. |
+| `ai.unload()` | Cancels active work, releases the Wllama session, and returns flat unloaded status; verified DBOPFS cache remains. |
+| `ai.dispose()` | Permanently disposes the controller; explicit `store.remove(source)` is required to delete cached model bytes. |
+
+The controller emits `statechange` and `progress` through
+`addEventListener()`, `removeEventListener()`, or `on()`. Event `detail` is the
+current frozen status. Provider states are `unloaded`, `loading`, `ready`,
+`unloading`, and `error`.
+
+## Model authority and cache admission
+
+`createBrowserModelSource()` requires `id`, `name`, `immutableUrl`, `bytes`,
+`sha256`, `licenseSpdx`, and `sourceRevision`. The URL must be absolute HTTPS
+without credentials or a fragment. Revision-floating `main`, `master`, and
+`latest` path segments are rejected. `name` is one filename. `bytes` is a
+positive safe integer and `sha256` is exactly 64 hexadecimal characters.
+
+`licenseSpdx` and `sourceRevision` are required provenance labels supplied by
+the caller; the SDK does not independently prove the license or derive the
+revision from the URL. Redirects are followed and the final URL must remain
+HTTPS. Byte length and SHA-256 remain the actual admission authority.
+
+The DBOPFS adapter stores model bytes and then commits an
+`arcane.ai.browser-wasm.model.v2` completion manifest. It reopens and fully
+rehashes the bytes before returning an installed receipt and again before every
+verified cache reuse. Missing, malformed, stale, wrong-length, or wrong-digest
+entries are removed. `load({offline:true})` never performs a model request; it
+uses a fully rehashed cache or rejects with `ARCANE_AI_MODEL_OFFLINE_MISS`.
+
+`localOnly:true` describes inference after load. It does not mean a cache miss
+cannot download. Source downloads use CORS, omit credentials and referrer,
+disable HTTP caching, and honor `AbortSignal`.
+
+## Streaming, cancellation, and tools
+
+```javascript
+const abort = new AbortController();
+const stream = ai.llm.stream({
+    localOnly:true,
+    signal:abort.signal,
+    messages:[{role:'user', content:'Summarize this text.'}],
+    maxTokens:128
+});
+
+const cancelButton = document.querySelector('[data-cancel-local-ai]');
+const cancel = () => abort.abort('user cancelled');
+cancelButton.addEventListener('click', cancel, {once:true});
+try {
+    for await (const chunk of stream) renderChunk(chunk);
+    const completion = await stream.result;
+    renderCompletion(completion);
+} catch (error) {
+    if (error?.code !== 'ARCANE_AI_REQUEST_ABORTED') throw error;
+    renderCancelled();
+} finally {
+    cancelButton.removeEventListener('click', cancel);
+}
+```
+
+An active cancellation rejects as `ARCANE_AI_REQUEST_ABORTED`. Requests are
+serialized; provider status exposes `busy` and `queued`. Supported request
+generation fields include temperature, top-K, top-P, min-P, repeat penalty,
+maximum tokens, seed, and stop sequences. Load settings separately include
+`contextTokens`, `batchTokens`, `microBatchTokens`, `threads`, and GPU-layer
+count. WebGPU is optional; cross-origin isolation and hardware fields are
+observations, not readiness promises.
+
+Tool definitions, tool choice, parallel-tool-call preference, and JSON or JSON
+Schema structured-output requests are passed to Wllama. Returned tool calls are
+validated and surfaced as structural data. Argument payloads remain JSON
+strings. The SDK never invokes a handler or executes a tool; application code
+must review policy, validate arguments, choose whether to execute, and submit a
+later tool result.
+
+## Errors and unavailable states
+
+Invalid configuration can throw `TypeError` or `RangeError`. Operational
+failures expose a stable `.code`; the internal error class is not exported.
+Handle the narrow code needed by the current operation and treat other failures
+as unavailable.
+
+| Area | Stable codes |
+| --- | --- |
+| Source and download | `ARCANE_AI_MODEL_SOURCE_INVALID`, `ARCANE_AI_MODEL_SOURCE_UNAVAILABLE`, `ARCANE_AI_MODEL_DOWNLOAD_FAILED`, `ARCANE_AI_MODEL_REDIRECT_BLOCKED`, `ARCANE_AI_MODEL_SIZE_MISMATCH`, `ARCANE_AI_MODEL_DIGEST_MISMATCH` |
+| Cache and storage | `ARCANE_AI_MODEL_CACHE_REJECTED`, `ARCANE_AI_MODEL_OFFLINE_MISS`, `ARCANE_AI_STORAGE_UNAVAILABLE`, `ARCANE_AI_STORAGE_READ_FAILED`, `ARCANE_AI_STORAGE_DELETE_FAILED` |
+| Lifecycle | `ARCANE_AI_UNAVAILABLE`, `ARCANE_AI_NOT_READY`, `ARCANE_AI_LOAD_FAILED`, `ARCANE_AI_UNLOAD_FAILED`, `ARCANE_AI_DISPOSE_FAILED`, `ARCANE_AI_DISPOSED`, `ARCANE_AI_OPERATION_SUPERSEDED` |
+| Requests | `ARCANE_AI_REQUEST_ABORTED`, `ARCANE_AI_REQUEST_FAILED`, `ARCANE_AI_INVALID_PROVIDER_RESULT`, `ARCANE_AI_LOCAL_ONLY_UNAVAILABLE`, `ARCANE_AI_ADAPTER_PROTOCOL_MISMATCH` |
+| Diagnostics | `ARCANE_AI_PROBE_FAILED` |
+
+`capabilities()` reports browser observations such as WebAssembly, OPFS,
+WebGPU, secure context, cross-origin isolation, and hardware concurrency.
+Feature-detect them. The authoritative Chrome behavior passes without
+cross-origin isolation, so that flag is not a hard gate. `probe()` exercises
+packaged Wllama backend operations only while unloaded; it neither admits nor
+downloads a model.
+
+## BROWSER_WASM_RUNTIME_AUTHORITY
+
+### Overview
+
+Deep-frozen identity for the shipped browser runtime. Its protocol is
+`arcane-ai-browser-wasm/1`; the provider adapter uses
+`arcane-ai-adapter/1`. It records Wllama `3.6.0`, the embedded llama.cpp
+revision, authenticated module/WASM byte lengths and SHA-256 values, licenses,
+and the disabled compatibility-runtime and remote-model-helper policy.
+
+### Value and import
+
+```text
+const BROWSER_WASM_RUNTIME_AUTHORITY
+```
+
+### Availability and normalization
+
+**Browser metadata; safely inspectable without loading a model.** The value is
+an immutable receipt, not a provider instance, model catalog, or capability
+grant.
+
+### Example
+
+```javascript
+import {BROWSER_WASM_RUNTIME_AUTHORITY} from 'arcane-os/ai/browser-wasm';
+
+console.log(BROWSER_WASM_RUNTIME_AUTHORITY.protocol);
+console.log(BROWSER_WASM_RUNTIME_AUTHORITY.package.version); // 3.6.0
+```
+
+## createArcaneAI()
+
+### Overview
+
+Creates the application-facing facade around a provider or an existing LLM
+controller. Use this as the primary browser-local API; construct the source,
+store, and Wllama provider beneath it.
+
+### Signature and result
+
+```text
+createArcaneAI({ llm=null, provider=null, loadPolicy='on-demand' }={})
+```
+
+At least one `llm` or `provider` is required; when both are supplied, `llm`
+takes precedence. `loadPolicy` is `on-demand` or `manual`. The frozen result
+contains `llm`, `runtime`, `status`, `load`,
+`unload`, `probe`, `fetchRequest`, `streamRequest`, and `dispose`.
+
+### Availability and normalization
+
+**Browser.** It normalizes provider lifecycle and request observation without
+selecting a model, changing browser permissions, contacting Arcane Core, or
+creating a fallback provider.
+
+### Example
+
+```javascript
+const ai = createArcaneAI({provider, loadPolicy:'manual'});
+const off = ai.llm.on('statechange', event => renderStatus(event.detail));
+await ai.load({offline:true});
+off();
+```
+
+## createBrowserModelSource()
+
+### Overview
+
+Validates caller-owned model provenance and creates the one cancellable HTTPS
+download source accepted by this provider.
+
+### Signature and result
+
+```text
+createBrowserModelSource(descriptor, { fetchImpl=null }={})
+```
+
+The frozen source includes `kind`, the seven canonical descriptor fields,
+`descriptor`, and `open({signal})`. `open()` returns a readable response body,
+requested/final URLs, and `cancel()`; it does not admit bytes to the cache.
+
+### Availability and normalization
+
+**Browser Fetch with CORS.** URL and metadata syntax are normalized; exact
+length and SHA-256 are enforced when the store installs the stream.
+
+### Example
+
+```javascript
+const source = createBrowserModelSource(MODEL);
+console.log(source.id, source.bytes, source.sha256);
+```
+
+## createBrowserWasmLlmProvider()
+
+### Overview
+
+Creates the local-only Wllama provider from genuine source and store objects
+created by this module. Structural lookalikes are rejected.
+
+### Signature and result
+
+```text
+createBrowserWasmLlmProvider({ source, store, loadDefaults={}, logger=console }={})
+```
+
+The frozen result exposes protocol and provider identity, model metadata,
+`capabilities`, `status`, `load`, `unload`, `chat`, `stream`, `streamChat`,
+`use`, `probe`, and `dispose`. Direct provider `load()` returns `{model,status}`;
+the facade `ai.load()` returns the flat controller status.
+
+### Availability and normalization
+
+**Browser with WebAssembly and verified DBOPFS model bytes.** Inference is local
+after load. WebGPU is optional and defaults to zero GPU layers unless the caller
+selects otherwise.
+
+### Example
+
+```javascript
+const provider = createBrowserWasmLlmProvider({
+    source,
+    store,
+    loadDefaults:{threads:1, contextTokens:4096, gpuLayers:0}
+});
+console.log(provider.status().state); // unloaded
+```
+
+## createDbopfsModelStore()
+
+### Overview
+
+Adapts an existing DBOPFS instance without renaming or replacing its public
+methods. The adapter owns verified model-file and completion-manifest behavior.
+
+### Signature and result
+
+```text
+createDbopfsModelStore({ dbopfs, tableName='arcane_ai_browser_models' }={})
+```
+
+The frozen result contains `kind`, `tableName`, the original `adapter`, and
+`ready`, `openVerified`, `install`, `ensure`, and `remove`. `ensure()` returns a
+file, completion manifest, and cache state `verified` or `installed`.
+
+### Availability and normalization
+
+**Browser with a ready DBOPFS instance and OPFS.** Cache receipts are local
+integrity evidence. They are not transferable capability tokens and do not
+prove model license rights.
+
+### Example
+
+```javascript
+const store = createDbopfsModelStore({dbopfs});
+await store.ready();
+const cached = await store.openVerified(source);
+console.log(cached ? 'verified cache' : 'cache miss');
+```
+
+## Related reference
+
+- [Canonical `createArcaneAI()` entry](../sdk-api.md#createarcaneai) and the
+  sibling [`BROWSER_WASM_RUNTIME_AUTHORITY`](../sdk-api.md#browserwasmruntimeauthority),
+  [`createBrowserModelSource()`](../sdk-api.md#createbrowsermodelsource),
+  [`createBrowserWasmLlmProvider()`](../sdk-api.md#createbrowserwasmllmprovider),
+  and [`createDbopfsModelStore()`](../sdk-api.md#createdbopfsmodelstore) entries
+- [Browser-local normalization boundary](../availability-and-normalization.md#browser-local-provider-adapter)
+- [Authenticated browser runtime delivery](../protocols.md#browser-runtime-delivery)
+- [Browser-WASM behavior evidence](../behavioral-testing.md#behavioral-coverage-model)
+- [DBOPFS runtime module](../runtime-modules.md#dbopfsjs)

package/docs/reference/availability-and-normalization.md

@@ -29,6 +29,7 @@ version; WebKitGTK availability must not be generalized to macOS.
 | Scaffold, inspect, test, package, bundle, build, verify, or run an app | `arcane` CLI or `arcane-os` package functions | **Node**; native targets invoke one explicit provider | CLI events and SDK errors/results are normalized by versioned SDK contracts. Native artifact receipts remain target-specific inside a common receipt lifecycle. |
 | Publish application events or review a bounded event history | `arcane-os/event-manager` | **Node** and **Browser**; optional DOM capture needs a browser DOM or compatible host | Live listeners receive original arguments. Recorded payloads and metadata become bounded, redacted, deeply frozen `arcane-event-stack/1` snapshots. The stack format is local diagnostic data, not a host transport. |
 | Build browser UI and app-local behavior | `/arcane/modules/*.js`, shared entities, and components | **Browser**; many modules also run inside every native renderer | Pure modules own their result contracts. Modules that call `Arcane` inherit the bridge boundary described below. |
+| Run a caller-selected local LLM entirely in a browser renderer | `arcane-os/ai/browser-wasm` through `createArcaneAI()` | **Browser** only; WebAssembly and OPFS/DBOPFS are required, WebGPU is optional, and a cache miss uses the caller's admitted HTTPS model URL unless `offline:true` | The facade normalizes lifecycle, status, streaming, cancellation, and structural tool-call visibility. Model URL, byte length, SHA-256, license identifier, and revision remain explicit caller authority. |
 | Read host identity, capabilities, storage, preferences, appearance, or platform state | `globalThis.Arcane` | **Cross-host** where the method is implemented and admitted | Promise behavior and `Arcane.Error` are normalized. Result fields are normalized unless the method explicitly documents a platform-dependent snapshot. |
 | Use local AI without coupling app code to Ollama HTTP | `Arcane.localAI`, `Arcane.ai`, or `/arcane/modules/Ollama.js` | Primarily **Native**; Android exposes a narrower admitted inference projection | Admission, errors, and managed-operation events are normalized. Direct Ollama response envelopes remain **Provider-native**. |
 | Use OpenAI from the renderer profile | `/arcane/modules/AI.js` | **Cloud** from an allowed browser/native renderer | High-level AI chat/text behavior is normalized by the module; raw provider diagnostics and some response detail remain provider-specific. No automatic cloud fallback is inferred from local failure. |
@@ -77,6 +78,22 @@ deeply frozen, and strictly importable as `arcane-event-stack/1`. DOM
 instrumentation adds browser diagnostics only; it does not replay browser
 state. See [EventManager and time-travel review](event-manager.md).
 
+### Browser-local provider adapter
+
+[`arcane-os/ai/browser-wasm`](ai/browser-wasm.md) exposes the same
+`arcane-ai-adapter/1` LLM lifecycle used by `createArcaneAI()`, while its
+packaged Wllama engine and caller-supplied model run inside the browser. This
+surface does not require an Arcane Core method grant because it does not call a
+Core host. Browser Fetch, CORS, storage policy, secure-context behavior, and
+resource limits still apply.
+
+`localOnly:true` describes inference after load; it does not promise that load
+is offline. A normal cache miss downloads from the exact caller-supplied HTTPS
+URL. `load({offline:true})` permits only an existing cache entry whose model
+bytes are fully rehashed, otherwise it rejects with
+`ARCANE_AI_MODEL_OFFLINE_MISS`. Tool calls are result data for application
+review and dispatch; the SDK never executes them.
+
 ### Arcane bridge-normalized
 
 Core-backed calls return promises and reject with `Arcane.Error`. Transport

package/docs/reference/behavioral-testing.md

@@ -37,6 +37,7 @@ release acceptance.
 | EventManager and event stacks | Live pub/sub ordering and payload identity, nested causation, immutable/redacted snapshots, strict import, bounded overflow, seek, all playback modes/lifecycle outcomes, cancellation, and DOM start/stop/privacy behavior. | Real user journeys and browser layout belong in a browser harness; event-stack review never proves that external side effects can be replayed. |
 | CLI | Commands parse, acknowledge, select one scope, produce normalized human/JSON/NDJSON output, propagate cancellation/failure, and reject invalid cardinality. | Native build/run requires the selected real provider and host. |
 | Browser runtime modules | Every shipped ESM module parses and its export inventory matches the catalog; pure helpers run focused success/error cases. | DOM, OPFS, media, and Web Component journeys use a browser harness. |
+| Browser-WASM local AI | The exact five-export namespace, runtime authority, model-source validation, DBOPFS adapter contract, provider/facade lifecycle, lazy/manual policy, abort normalization, and structural-only tool behavior run with bounded deterministic providers. | The publication gate installs the packed SDK into a real Chrome app, loads the authenticated Wllama 3.6.0 JS/WASM assets, performs a cold exact-length/SHA-256 model install, real inference, in-flight cancellation, unload, and a verified offline reload with zero model requests. It is an explicit heavyweight capability gate, not an implicit model download in every local `npm run check`. |
 | Core bridge docs | Canonical namespace/method/event/entity inventories match their one-per-member guides and required sections. | Live Core conformance belongs in Arcane OS because Core implementation is not shipped as SDK source. |
 | Arcane Ollama wrapper | Missing-host error, method forwarding, text/readiness normalization, unload request, and stream-option forwarding run against a deterministic fake `Arcane.ollama`. | Real managed-service, model download/create, GPU/resource admission, and service restart require an admitted Arcane host. |
 | Native providers | Plan/provider protocol, explicit target, receipt authentication, artifact reader, and unavailable-path honesty are tested with bounded fixtures. | Exact Windows, Linux, or Android artifact verification and launch must run on that actual platform/architecture. |
@@ -53,6 +54,13 @@ client contract. They must assert the exact request sent to the fake and the
 normalized result returned to the application. A fake provider never counts as
 native host, artifact, installation, or model-service evidence.
 
+The browser-WASM guide follows the same rule: it shows exact model authority
+and wiring, but leaves the download/load call behind an explicit user action.
+The authoritative browser contract separately proves that admitted bytes are
+hashed before DBOPFS completion metadata is committed, cached bytes are rehashed
+before offline reuse, `AbortSignal` settles as `ARCANE_AI_REQUEST_ABORTED`, and
+tool-call arguments are surfaced without invoking application handlers.
+
 ## Host and normalization cases
 
 Cross-host APIs should cover at least these cases at their owning layer:

package/docs/reference/cli.md

@@ -183,8 +183,8 @@ identical executable alias.
 The generated artifact is
 `apps/<id>/modules/arcane.importmap.json`. Its exact JSON is also installed in
 the app entry as `<script type="importmap" data-arcane-import-map>` before
-module loading. In SDK `0.1.0`, the authenticated physical-v1 runtime produces
-85 entries and intentionally has no package-root mapping.
+module loading. In SDK `0.1.1`, the authenticated physical-v1 runtime produces
+86 entries and intentionally has no package-root mapping.
 
 ### Result and safety
 
@@ -201,7 +201,7 @@ Success returns the normal selected-workspace wrapper:
         artifactRelativePath,
         entryPath,
         imports,
-        entryCount:85,
+        entryCount:86,
         excludedModules:['modules/CaseEvidenceIndexer.js'],
         files:[
             {role:'artifact',path,bytes,sha256},

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

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "sdkVersion": "0.1.0",
+  "sdkVersion": "0.1.2",
   "environment": {
-    "runtime": "Node.js",
-    "minimumVersion": "22.23.2",
+    "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
+    "minimumVersion": "22.23.2 for Node entrypoints",
     "moduleSystem": "ESM"
   },
-  "memberCount": 158,
+  "memberCount": 163,
   "members": [
     {
       "id": "root:APP_BUNDLE_DESCRIPTOR_NAME",
@@ -2627,6 +2627,86 @@
       "availability": "Node; on-demand CLI or maintainer check only",
       "protocol": "Approved credential-free HTTPS registry origin",
       "normalization": "Returns a normalized URL object only for an exact allowed root origin"
+    },
+    {
+      "id": "browser-wasm:BROWSER_WASM_RUNTIME_AUTHORITY",
+      "name": "BROWSER_WASM_RUNTIME_AUTHORITY",
+      "displayName": "BROWSER_WASM_RUNTIME_AUTHORITY",
+      "kind": "constant",
+      "signature": "const BROWSER_WASM_RUNTIME_AUTHORITY",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Deep-frozen authority for the packaged Wllama and llama.cpp runtime, authenticated JS and WASM assets, licensing, and disabled compatibility-network policy.",
+      "availability": "Browser metadata; import and inspection require neither DBOPFS nor a loaded model",
+      "protocol": "arcane-ai-browser-wasm/1 over the provider-neutral arcane-ai-adapter/1 boundary",
+      "normalization": "Exact immutable runtime and component identity; it contains no model weights or model catalog"
+    },
+    {
+      "id": "browser-wasm:createArcaneAI",
+      "name": "createArcaneAI",
+      "displayName": "createArcaneAI()",
+      "kind": "function",
+      "signature": "createArcaneAI({ llm=null, provider=null, loadPolicy='on-demand' }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Creates the provider-neutral browser AI facade and LLM lifecycle controller around one compatible provider or controller.",
+      "availability": "Browser; the selected provider observes its own WebAssembly, storage, and model readiness",
+      "protocol": "arcane-ai-adapter/1",
+      "normalization": "Normalizes lazy or manual load, lifecycle status, cancellation, streaming completion, and structural tool-call visibility without executing tools"
+    },
+    {
+      "id": "browser-wasm:createBrowserModelSource",
+      "name": "createBrowserModelSource",
+      "displayName": "createBrowserModelSource()",
+      "kind": "function",
+      "signature": "createBrowserModelSource(descriptor, { fetchImpl=null }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Validates a caller-supplied immutable HTTPS model authority and creates its cancellable no-credentials download source.",
+      "availability": "Browser with Fetch and a readable response body; each direct open call performs its configured HTTPS fetch",
+      "protocol": "Caller-supplied exact model URL, expected byte length, SHA-256, license identifier, and source revision",
+      "normalization": "Canonical frozen descriptor and download handle; byte integrity is verified by the model store before admission"
+    },
+    {
+      "id": "browser-wasm:createBrowserWasmLlmProvider",
+      "name": "createBrowserWasmLlmProvider",
+      "displayName": "createBrowserWasmLlmProvider()",
+      "kind": "function",
+      "signature": "createBrowserWasmLlmProvider({ source, store, loadDefaults={}, logger=console }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Creates the packaged Wllama browser provider with verified model admission, serialized inference, streaming, abort, unload, and probe operations.",
+      "availability": "Browser; WebAssembly required, WebGPU optional, and model loading requires verified DBOPFS bytes",
+      "protocol": "arcane-ai-adapter/1 with OpenAI-like chat completion and streaming envelopes",
+      "normalization": "Frozen lifecycle/status/capability records and structured tool-call data; the SDK never invokes application tools"
+    },
+    {
+      "id": "browser-wasm:createDbopfsModelStore",
+      "name": "createDbopfsModelStore",
+      "displayName": "createDbopfsModelStore()",
+      "kind": "function",
+      "signature": "createDbopfsModelStore({ dbopfs, tableName='arcane_ai_browser_models' }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Adapts an existing DBOPFS instance into an authenticated model cache that commits metadata last and rehashes cached bytes before reuse.",
+      "availability": "Browser with a ready DBOPFS instance and OPFS support",
+      "protocol": "arcane.ai.browser-wasm.model.v2 completion manifests over existing DBOPFS method semantics",
+      "normalization": "Returns verified or installed cache receipts, fail-closed offline misses, progress snapshots, and explicit removal without changing DBOPFS public names"
     }
   ]
 }

package/docs/reference/protocols.md

@@ -104,8 +104,8 @@ import ollama from 'arcane/Ollama';
 ```
 
 The authenticated physical-v1 tree lives entirely beneath `arcane/`. It
-contains 155 pinned Arcane runtime files plus eight SDK browser-runtime files:
-163 files in all. Runtime `strong-type` 1.1 stays under
+contains 155 pinned Arcane runtime files plus 18 SDK browser-runtime files:
+173 files in all. Runtime `strong-type` 1.1 stays under
 `arcane/dependencies/strong-type/`; the focused SDK event surface lives under
 `arcane/sdk/`, with `event-pubsub` 6.1 and its sibling `strong-type` 2.0 under
 `arcane/sdk/dependencies/`. This URL-key separation prevents the runtime and SDK
@@ -114,13 +114,14 @@ app plus that authenticated tree. Packaging copies the same map, app entry, and
 physical bytes into `dist/<id>`; targets never resolve through the consumer
 workspace's root `node_modules/`.
 
-In SDK `0.1.0`, the generated map has exactly 85 entries: 73 named
-`arcane/*` modules, nine `arcane/entities/*` modules, and these three focused or
+In SDK `0.1.1`, the generated map has exactly 86 entries: 73 named
+`arcane/*` modules, nine `arcane/entities/*` modules, and these four focused or
 compatibility mappings:
 
 | Browser specifier | Physical target |
 | --- | --- |
 | `arcane-os/event-manager` | `./arcane/sdk/event-manager.mjs` |
+| `arcane-os/ai/browser-wasm` | `./arcane/sdk/ai/browser-wasm.mjs` |
 | `event-pubsub` | `./arcane/sdk/dependencies/event-pubsub/index.js` |
 | `./node_modules/strong-type/index.js` | `./arcane/dependencies/strong-type/index.js` |
 
@@ -167,14 +168,14 @@ heartbeat is event telemetry only and never regenerates browser state.
 
 `arcane.lock.json.sdkBrowserRuntime` persists the trusted manifest path,
 `manifestSha256`, `contentSha256`, `builder`, `sdkVersion`, and `source` record.
-For SDK `0.1.0` those identities are:
+For SDK `0.1.1` those identities are:
 
 ```text
 manifest: node_modules/arcane-os/browser-runtime/ARCANE_SDK_BROWSER_RELEASE.json
-manifestSha256: 43baaec850291c28795f6c194001deb5febab88ccab1b033bce6597dd6f6f08f
-contentSha256: 0caa302bc07d4a45f5290504ec62ddce98fdf5e3412f916c10aae3d51b1e5f7c
+manifestSha256: 33396b3d35322b784929270e7ca0a2a8b31d899c6e77bcb227edc95b37d0ae7d
+contentSha256: 5e03f45a732db51cb5a2b2193cc79ecda34501d07a9b2e82e794e5fa37d55d00
 builder: arcane-sdk-browser-runtime-v1
-sdkVersion: 0.1.0
+sdkVersion: 0.1.1
 source.protocol: arcane-sdk-browser-runtime/1
 source.browserEntry: arcane-os/event-manager
 ```

package/docs/reference/sdk-api.md

@@ -1,6 +1,10 @@
 # Arcane OS SDK JavaScript API
 
-The npm package exposes a Node.js ESM control plane. It is not a browser-importable renderer API. Application code uses named modules from the managed browser map, such as `arcane/ThemeBootstrap`, uses the focused `arcane-os/event-manager` browser entry when needed, and calls `globalThis.Arcane` for capability-gated host behavior.
+The npm package exposes a Node.js ESM control plane, the Node-and-browser
+`arcane-os/event-manager` entrypoint, and the browser-only
+`arcane-os/ai/browser-wasm` entrypoint. Application code otherwise uses named
+modules from the managed browser map, such as `arcane/ThemeBootstrap`, and
+calls `globalThis.Arcane` for capability-gated host behavior.
 
 This page is the canonical inventory for every JavaScript name reachable through `package.json#exports`. The same binding can appear at the root and a focused subpath; those entrypoints are listed together. The root workspace `discoverApps` and the low-level packager `discoverApps` are intentionally separate records because they are different functions.
 
@@ -10,7 +14,7 @@ This table is the Node `package.json#exports` map: it defines package
 entrypoints for SDK/tooling code. It is distinct from the generated browser
 import map that resolves application-facing `arcane/*` modules and the focused
 EventManager entry. See [browser runtime delivery](protocols.md#browser-runtime-delivery)
-for that 85-entry physical-runtime contract.
+for that 86-entry physical-runtime contract.
 
 | Specifier | Purpose |
 | --- | --- |
@@ -25,6 +29,7 @@ for that 85-entry physical-runtime contract.
 | `arcane-os/packager` | Low-level browser app packager. |
 | `arcane-os/release-bundle` | Deterministic external release bundles. |
 | `arcane-os/event-manager` | Central synchronous events, bounded time-travel history, playback, and optional DOM instrumentation. |
+| `arcane-os/ai/browser-wasm` | Caller-authenticated browser-local Wllama inference, verified DBOPFS model caching, streaming, cancellation, and structural tool-call results. |
 
 JSON schemas, the runtime manifest, and `package.json` are data-only export subpaths. In Node ESM, import JSON with `with {type: 'json'}`, or resolve and read it explicitly.
 
@@ -74,14 +79,19 @@ Protocol mechanics are intentionally kept in the [deep protocol guide](protocols
 | `authenticateSharedPayloadSnapshot()` | function | `arcane-os` | Packaging and release bundles | Node |
 | `buildApplication()` | function | `arcane-os` | Headless toolchain operations | Node; selected operation may produce browser or native output |
 | `buildTarget()` | function | `arcane-os` | Targets, native plans, and providers | Node; selected browser/native target or provider as documented |
+| `BROWSER_WASM_RUNTIME_AUTHORITY` | constant | `arcane-os/ai/browser-wasm` | Browser-WASM local AI | Browser metadata; no model or DBOPFS required to inspect |
 | `bumpVersion()` | function | `arcane-os/packager` | Packaging and release bundles | Node |
 | `bundleApplication()` | function | `arcane-os` | Headless toolchain operations | Node; selected operation may produce browser or native output |
 | `checkApplication()` | function | `arcane-os` | Headless toolchain operations | Node; selected operation may produce browser or native output |
 | `CLI_EVENT_PROTOCOL` | constant | `arcane-os` | Identity and protocol constants | Node |
 | `CLI_NAME` | constant | `arcane-os` | Identity and protocol constants | Node |
 | `createApplication()` | function | `arcane-os` | Headless toolchain operations | Node; selected operation may produce browser or native output |
+| `createArcaneAI()` | function | `arcane-os/ai/browser-wasm` | Browser-WASM local AI | Browser; compatible LLM provider or controller required |
 | `createAppReleaseBundle()` | function | `arcane-os` | Packaging and release bundles | Node |
+| `createBrowserModelSource()` | function | `arcane-os/ai/browser-wasm` | Browser-WASM local AI | Browser Fetch with a readable response body |
+| `createBrowserWasmLlmProvider()` | function | `arcane-os/ai/browser-wasm` | Browser-WASM local AI | Browser; WebAssembly and verified DBOPFS model bytes |
 | `createCanonicalUstarHeader()` | function | `arcane-os` | Packaging and release bundles | Node |
+| `createDbopfsModelStore()` | function | `arcane-os/ai/browser-wasm` | Browser-WASM local AI | Browser with a ready DBOPFS instance and OPFS |
 | `createNativeBuildPlan()` | function | `arcane-os` | Targets, native plans, and providers | Node; selected browser/native target or provider as documented |
 | `createNativeTargetAdapter()` | function | `arcane-os` | Targets, native plans, and providers | Node; selected browser/native target or provider as documented |
 | `createReporter()` | function | `arcane-os` | Events, processes, and testing | Node |
@@ -2645,7 +2655,7 @@ The import-map operation also reports the stable operation-specific strings
 `ARCANE_IMPORT_MAP_COLLISION`; package assembly can additionally report
 `ARCANE_IMPORT_MAP_CLEANUP_FAILED`. They are normalized `ArcaneError.code`
 values, but are not properties added to this frozen general registry in SDK
-`0.1.0`.
+`0.1.1`.
 
 ### Value and import
 
@@ -3464,7 +3474,7 @@ const toolchain = createToolchain({
 
 // Only this explicit call refreshes the managed map and HTML entry.
 const result = await toolchain.importMap();
-console.log(result.importMap.entryCount); // 85 in SDK 0.1.0
+console.log(result.importMap.entryCount); // 86 in SDK 0.1.1
 ```
 
 ## describeTargets()
@@ -4925,6 +4935,200 @@ const stack = parseEventStack(serialized);
 console.log(stack.sessionId, stack.events.length);
 ```
 
+## BROWSER_WASM_RUNTIME_AUTHORITY
+
+### Overview
+
+Deep-frozen authority for the browser-only runtime behind
+`arcane-os/ai/browser-wasm`. It records protocol
+`arcane-ai-browser-wasm/1`, `@wllama/wllama` `3.6.0`, the embedded llama.cpp
+revision, the exact packaged JavaScript and WebAssembly assets, retained MIT
+licenses, and the disabled compatibility-runtime/remote-model-helper policy.
+It contains no model weights or model catalog.
+
+### Value and import
+
+```text
+const BROWSER_WASM_RUNTIME_AUTHORITY
+```
+
+The value is available from `arcane-os/ai/browser-wasm` only. Importing and
+inspecting it does not initialize Wllama, request storage, or download a model.
+
+### Availability and normalization
+
+**Browser metadata.** This is an immutable component receipt, not a provider,
+model, browser-permission grant, or proof that WebAssembly/OPFS is available.
+
+### Example
+
+```javascript
+import {BROWSER_WASM_RUNTIME_AUTHORITY} from 'arcane-os/ai/browser-wasm';
+
+console.log(BROWSER_WASM_RUNTIME_AUTHORITY.protocol);
+console.log(BROWSER_WASM_RUNTIME_AUTHORITY.package.version);
+```
+
+Complete lifecycle, model authority, cache, cancellation, and tool behavior:
+[Browser-WASM local AI](ai/browser-wasm.md).
+
+## createArcaneAI()
+
+### Overview
+
+Creates the application-facing LLM facade around a compatible provider or
+controller. The default `on-demand` policy loads before first use; `manual`
+requires an explicit successful `load()` before requests. When both `llm` and
+`provider` are supplied, `llm` takes precedence.
+
+### Signature and result
+
+```text
+createArcaneAI({ llm=null, provider=null, loadPolicy='on-demand' }={})
+```
+
+At least one `llm` or `provider` is required. The frozen facade contains
+`llm`, `runtime`, `status`, `load`, `unload`, `probe`, `fetchRequest`,
+`streamRequest`, and `dispose`. `status()` returns `{llm: status}`; lifecycle
+methods return the flat LLM status. `fetchRequest()` returns the completion.
+`streamRequest()` consumes streaming and returns text or a tool-name-to-JSON-
+argument-string record. Use `ai.llm.stream()` for the async iterator.
+
+### Availability and normalization
+
+**Browser.** It normalizes lifecycle, state/progress events, lazy/manual use,
+cancellation, completions, and structural tool-call visibility. It neither
+selects a provider fallback nor executes an application tool.
+
+### Example
+
+```javascript
+const ai = createArcaneAI({provider, loadPolicy:'manual'});
+const stop = ai.llm.on('progress', event => renderProgress(event.detail));
+await ai.load({offline:true});
+stop();
+```
+
+## createBrowserModelSource()
+
+### Overview
+
+Validates a caller-owned model descriptor and creates the cancellable HTTPS
+source accepted by the browser-WASM store/provider. Required fields are `id`,
+`name`, `immutableUrl`, `bytes`, `sha256`, `licenseSpdx`, and
+`sourceRevision`. `bytes` is the expected positive safe-integer byte length,
+not inline data.
+
+### Signature and result
+
+```text
+createBrowserModelSource(descriptor, { fetchImpl=null }={})
+```
+
+The URL must be absolute HTTPS with no credentials or fragment and no
+revision-floating `main`, `master`, or `latest` path. The SHA-256 value is
+exactly 64 hexadecimal characters. The frozen source exposes its canonical
+descriptor and `open({signal})`, which returns `{body, requestedUrl, finalUrl,
+cancel}`. Every direct `open()` performs the configured fetch. The SDK records
+but does not independently prove the supplied license identifier or revision.
+
+### Availability and normalization
+
+**Browser Fetch with CORS and a readable response body.** Downloads omit
+credentials/referrer, disable HTTP caching, follow redirects, require a final
+HTTPS URL, compare `Content-Length` when present, and honor `AbortSignal`.
+Actual length and digest admission belongs to the DBOPFS store.
+
+### Example
+
+```javascript
+const source = createBrowserModelSource({
+    id:'reviewed-model',
+    name:'model-q4.gguf',
+    immutableUrl:'https://models.example/revisions/4f7c/model-q4.gguf',
+    bytes:123456789,
+    sha256:'0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+    licenseSpdx:'Apache-2.0',
+    sourceRevision:'4f7c'
+});
+```
+
+## createBrowserWasmLlmProvider()
+
+### Overview
+
+Creates the packaged Wllama provider from genuine source and store objects
+created by this module. It serializes requests and exposes provider states
+`unloaded`, `loading`, `ready`, `unloading`, and `error`.
+
+### Signature and result
+
+```text
+createBrowserWasmLlmProvider({ source, store, loadDefaults={}, logger=console }={})
+```
+
+The frozen provider exposes `protocol`, `id`, `model`, `capabilities`,
+`status`, `load`, `unload`, `chat`, `stream`, `streamChat`, `use`, `probe`, and
+`dispose`. Load settings include offline mode, `AbortSignal`, progress,
+threads, context/batch/micro-batch tokens, and GPU layers. Chat supports
+OpenAI-like message/generation fields, tools, tool choice, parallel tool-call
+preference, and JSON/JSON-Schema structured output. `stream()` returns a frozen
+async iterator with `result` and `cancel(reason)`.
+
+### Availability and normalization
+
+**Browser with WebAssembly and a verified DBOPFS model.** WebGPU and
+cross-origin isolation are capability observations, not promised gates.
+Returned tools are validated structural data; the SDK never calls a handler.
+Cancellation normalizes to `ARCANE_AI_REQUEST_ABORTED`.
+
+### Example
+
+```javascript
+const provider = createBrowserWasmLlmProvider({
+    source,
+    store,
+    loadDefaults:{threads:1, contextTokens:4096, gpuLayers:0}
+});
+console.log(provider.status().state); // unloaded
+```
+
+## createDbopfsModelStore()
+
+### Overview
+
+Adapts an existing DBOPFS instance into an authenticated model cache without
+renaming its public methods. The adapter commits model bytes before the
+`arcane.ai.browser-wasm.model.v2` completion manifest and then reopens and
+rehashes the stored file.
+
+### Signature and result
+
+```text
+createDbopfsModelStore({ dbopfs, tableName='arcane_ai_browser_models' }={})
+```
+
+The frozen result contains `kind`, `tableName`, the original `adapter`, and
+`ready`, `openVerified`, `install`, `ensure`, and `remove`. `ensure()` returns
+`{file, manifest, cache:'verified'|'installed'}`. Every cache reuse rehashes the
+actual bytes. `offline:true` never downloads and rejects a miss with
+`ARCANE_AI_MODEL_OFFLINE_MISS`. Invalid cache records are removed fail closed.
+
+### Availability and normalization
+
+**Browser with a ready DBOPFS instance and OPFS.** The cache is local integrity
+evidence, not a transferable capability or license proof. Unload/dispose keep
+the cache; `store.remove(source)` explicitly deletes it.
+
+### Example
+
+```javascript
+const store = createDbopfsModelStore({dbopfs});
+await store.ready();
+const cached = await store.openVerified(source);
+console.log(cached ? 'verified cache' : 'cache miss');
+```
+
 ## Data export subpaths
 
 The package also exposes the exact runtime manifest, eight JSON Schemas (including `arcane-os/schemas/event-stack.json`), and its package manifest. These are data contracts, not callable JavaScript members. See [schema and manifest contracts](../architecture.md) and the files under `schemas/`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

package/runtime/ARCANE_RUNTIME_RELEASE.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "builder": "arcane-sdk-runtime-v1",
-  "sdkVersion": "0.1.1",
+  "sdkVersion": "0.1.2",
   "source": {
     "repository": "https://github.com/TheWizardNexus/ARCANE-OS.git",
     "commit": "567ad110bf57a1c2d4a3daa22ae93716cc5f4d7e",

package/schemas/arcane-lock.schema.json

@@ -28,7 +28,7 @@
           "const": "arcane-os"
         },
         "version": {
-          "const": "0.1.1"
+          "const": "0.1.2"
         }
       }
     },
@@ -69,7 +69,7 @@
           "const": "node_modules/arcane-os/browser-runtime/ARCANE_SDK_BROWSER_RELEASE.json"
         },
         "manifestSha256": {
-          "const": "33396b3d35322b784929270e7ca0a2a8b31d899c6e77bcb227edc95b37d0ae7d"
+          "const": "88395493b411fd5461fbb2bb065ae2b745f6d1672f796583fd248ec97f71f4f7"
         },
         "contentSha256": {
           "const": "5e03f45a732db51cb5a2b2193cc79ecda34501d07a9b2e82e794e5fa37d55d00"
@@ -78,7 +78,7 @@
           "const": "arcane-sdk-browser-runtime-v1"
         },
         "sdkVersion": {
-          "const": "0.1.1"
+          "const": "0.1.2"
         },
         "source": {
           "type": "object",

package/src/dev-server.mjs

@@ -31,6 +31,7 @@ const MIME_TYPES=new Map([
     ['.png','image/png'],
     ['.svg','image/svg+xml; charset=utf-8'],
     ['.txt','text/plain; charset=utf-8'],
+    ['.wasm','application/wasm'],
     ['.webp','image/webp'],
     ['.woff','font/woff'],
     ['.woff2','font/woff2']
@@ -51,7 +52,7 @@ const PRIVATE_SOURCE_SEGMENTS=new Set([
 // development CSP from being exposed as a general network service.
 const DEVELOPMENT_CSP=[
     "default-src 'self'",
-    "script-src 'self' 'unsafe-inline'",
+    "script-src 'self' 'unsafe-inline' 'wasm-unsafe-eval'",
     "style-src 'self' 'unsafe-inline'",
     "img-src 'self' data: blob: http: https:",
     "font-src 'self' data:",

package/src/doctor.mjs

@@ -8,7 +8,7 @@ import {runProcess} from './process.mjs';
 import {ARCANE_PROTOCOL,SDK_VERSION} from './constants.mjs';
 import {ERROR_CODES,ArcaneError,throwIfAborted} from './errors.mjs';
 
-const MINIMUM_NODE=[22,14,0];
+const MINIMUM_NODE=[22,23,2];
 const WINDOWS_SERVICE_NAME='ArcaneOllama';
 const WINDOWS_SERVICE_HOST='C:\\Program Files\\Ollama\\ArcaneOllamaService.exe';
 const WINDOWS_SERVICE_COMMAND=`"${WINDOWS_SERVICE_HOST}"`;

package/src/sdk-browser-runtime.mjs

@@ -9,7 +9,7 @@ const MANIFEST_NAME='ARCANE_SDK_BROWSER_RELEASE.json';
 const BUILDER='arcane-sdk-browser-runtime-v1';
 const PROTOCOL='arcane-sdk-browser-runtime/1';
 export const SDK_BROWSER_RUNTIME_MANIFEST_SHA256=
-    '33396b3d35322b784929270e7ca0a2a8b31d899c6e77bcb227edc95b37d0ae7d';
+    '88395493b411fd5461fbb2bb065ae2b745f6d1672f796583fd248ec97f71f4f7';
 export const SDK_BROWSER_RUNTIME_CONTENT_SHA256=
     '5e03f45a732db51cb5a2b2193cc79ecda34501d07a9b2e82e794e5fa37d55d00';
 const REPOSITORY='https://github.com/TheWizardNexus/arcane-os-sdk.git';