arcane-os 0.53.0 → 0.54.0

package/docs/reference/protocols.md

@@ -174,6 +174,69 @@ output must remain separate; a conflicting native assembly fails before it
 packages any app. App launch paths, resource URLs, and enabled PWA
 representations retain their package-relative layout.
 
+## Native-module package output
+
+The public `packageApp` operation accepts `moduleFormat:'native'`. Omission, or
+`'import-map'`, retains ordinary browser output. Optional operation-level
+`outputDirectory` overrides only this invocation's destination; `verifyApp`
+accepts that same override. Configuration, source layout, app identity, storage
+scope and previously generated sibling outputs remain unchanged.
+
+The native transformation runs in the selected package stage after application
+adapter work, before the final inventory and any enabled PWA artifacts. It uses
+the existing selected document/runtime records and shared lexical/HTML owners.
+Each selected document supplies its saved maps and authored base. Native mode
+uses the static layout with map declarations before executable scripts; it does
+not reproduce late-map insertion or its already-resolved-module timing rules.
+Exact keys, longest matching prefixes and most-specific importer scopes resolve to package
+URLs, including URL aliases used by direct installed-SDK layouts. Static
+imports, re-exports, string-literal dynamic imports and string-literal
+`import.meta.resolve()` become native relative references. Query strings and
+fragments retain their meaning. Equivalent graphs share output modules;
+documents whose maps resolve differently receive distinct context files beside
+the original module, including when their graphs contain cycles.
+
+Selected document import-map elements are consumed in the output only.
+Executable inline document scripts move into complete external files while
+their script elements retain position, type and effective scheduling. The
+packager removes ineffective `async`/`defer` attributes only from formerly inline
+classic scripts, whose external form otherwise would activate those attributes.
+Module scripts and already-external document scripts retain their attributes.
+Imported component scripts use one canonical classic wrapper, with an explicit
+`data-arcane-packaged-script` marker consumed by `HTMLImport`. That path loads
+the external script directly and retains per-instance host binding, ordered
+asynchronous completion, cancellation, teardown and ready/error events. Ordinary
+browser components keep their existing inline path. Application documents not
+selected for document processing remain unchanged unless they are explicitly
+loaded as components.
+
+The selected payload is preserved in full, including runtime files, assets,
+workers and licenses. Graph processing follows each document's executable and
+resource references, including literal URLs to selected shared component HTML.
+It does not assign an unused shared file to another document's map. Unreferenced
+selected files retain their complete content. Referenced scripts, component HTML
+and stylesheets are processed at their existing owners; resource URLs are rebased
+for deployment under a directory such as `app/`. The operation adds generated scripts to the
+complete release inventory. It does not bundle, prune, minify or rewrite
+application prose, data or saved history. The existing stage replacement
+preserves prior output if packaging fails or is cancelled.
+
+This is a static module/script packaging capability, not a replacement browser
+or a runtime import-map interpreter. Computed import expressions remain authored;
+applications supply native-resolvable URLs for runtime-selected imports. It
+does not convert event-handler attributes, dynamically evaluated source, or
+provider-created executable blobs. An inline document script beneath an authored
+remote effective base cannot address a package-local generated file; native mode
+reports that incompatible transformation and preserves the original output.
+Already-external scripts retain their remote-base behavior. Remote modules/providers
+and WebAssembly still depend on their actual host capabilities. Resolving package references is
+distinct from executing the complete application on Chromium or another host.
+
+For an extension, select `browserPwa:false` for that artifact and place the
+complete SDK-produced app beneath the app-owned extension root. The application
+owns its manifest, toolbar/background launcher and permissions. Ordinary browser
+PWA configuration and generated browser output remain independently available.
+
 ## Installed-package browser routes
 
 An external application can serve and package its installed SDK directly,
@@ -413,7 +476,7 @@ renaming any preceding entry changes the physical contract.
 
 The map derives its complete entries from the selected runtime graph;
 application source imports do not select a fixed entry count. The operation
-result reports `imports`, `documentCount`, and `excludedModules`; reached-file
+result reports `imports`, optional dependency `scopes`, `documentCount`, and `excludedModules`; reached-file
 traversal remains internal. The
 managed graph exposes `arcane-os/event-manager`, `arcane-os/ai/browser-wasm`,
 `arcane-os/ai/browser-speech`, `arcane-os/preference-store`, and
@@ -425,6 +488,8 @@ The focused physical targets remain stable when their bindings are reached:
 | Browser specifier | Physical target |
 | --- | --- |
 | `arcane-os/event-manager` | `./arcane/sdk/event-manager.mjs` |
+| `arcane-os/websocket-client` | `./arcane/sdk/websocket-client.mjs` |
+| `ws-share` | `./arcane/sdk/dependencies/ws-share/WS.js` |
 | `arcane-os/ai/browser-wasm` | `./arcane/sdk/ai/browser-wasm.mjs` |
 | `arcane-os/ai/browser-speech` | `./arcane/sdk/ai/browser-speech.mjs` |
 | `arcane-os/speech-text` | `./arcane/sdk/speech-text.mjs` |
@@ -434,6 +499,16 @@ The focused physical targets remain stable when their bindings are reached:
 | `strong-type` | `./arcane/dependencies/strong-type/index.js` |
 | `./node_modules/strong-type/index.js` | `./arcane/dependencies/strong-type/index.js` |
 
+When the selected runtime contains event-pubsub's own dependency projection,
+the `./arcane/sdk/dependencies/event-pubsub/` scope maps `strong-type` to
+`./arcane/sdk/dependencies/event-pubsub/dependencies/strong-type/index.js`.
+This keeps its published 2.0.0 selection separate from the global SDK 2.0.1
+binding. Scope keys and targets follow installed-package and document-base
+translation together. Older inventories without that nested projection retain
+their existing map shape. Internal managed test contexts accept and preserve
+optional `scopes` alongside `imports`; their loader selects the most-specific
+matching importer scope before the global map.
+
 Direct installed routes translate these targets to their actual npm destinations,
 including aliases. There is no `arcane-os` package-root mapping or catch-all
 `arcane/` prefix. Classic scripts, workers, stylesheets, and other

package/docs/reference/runtime-modules.md

@@ -98,7 +98,8 @@ own asynchronous work, cancellation, and backpressure.
 | [`DocumentNavigation.js`](#documentnavigationjs) | esm | Binds document navigation, filtering, history, current-item reveal, and load initialization. | Browser / native WebView | Normalized filter/navigation state; DOM effects preserved. |
 | [`Errors.js`](#errorsjs) | esm | Normalizes global errors/rejections, assigns occurrence identifiers, persists a complete ledger, and performs complete delivery. | Browser / native WebView hybrid | Incident records normalized; storage/mail failures isolated. |
 | [`GifEncoder.js`](#gifencoderjs) | esm | Encodes indexed frames into a complete animated GIF using palette mapping and LZW. | Cross-host | Normalized complete binary output. |
-| [`HTMLImport.js`](#htmlimportjs) | esm | Defines the same-origin `<html-import>` loader with open shadow root, inline script execution, and readiness/error events. | Browser / native WebView | Public error detail normalized; fetch/DOM failure preserved. |
+| [`HTMLImport.js`](#htmlimportjs) | esm | Defines the same-origin `<html-import>` loader with open shadow root, inline or packaged external script execution, and readiness/error events. | Browser / native WebView | Public error detail normalized; fetch/DOM failure preserved. |
+| [`HTMLImportScript.js`](#htmlimportscriptjs) | esm | Renders the complete classic-script host wrapper shared by HTMLImport and native-module packaging. | Cross-host | Complete source retained with a terminating newline before the wrapper closes. |
 | [`InMemoryCommunicationProvider.js`](#inmemorycommunicationproviderjs) | esm | Implements deterministic in-memory thread/message/send behavior for demos and tests. | Cross-host | Normalized communication entities. |
 | [`IsolatedModelQuestionRunner.js`](#isolatedmodelquestionrunnerjs) | esm | Inspects one selected model and runs one isolated question while preserving the complete answer. | Native bridge or injected provider | Normalized model/result and coded errors. |
 | [`LocalAIReadiness.js`](#localaireadinessjs) | esm | Derives selected AI requirements and returns a complete readiness/recovery report across browser, desktop, and Android modes. | Browser/native hybrid | Fully normalized report and stable error codes; browsers never probe Ollama. |
@@ -2500,7 +2501,7 @@ console.log(Object.keys(module));
 
 ### Overview
 
-Defines the same-origin `<html-import>` loader with open shadow root, inline script execution, and readiness/error events.
+Defines the same-origin `<html-import>` loader with open shadow root, inline or packaged external script execution, and readiness/error events.
 
 ### Public surface
 
@@ -2520,6 +2521,14 @@ Local component resources use stable URLs. The loader removes retired SDK-owned
 including caller-owned `v` fields, and fragments remain intact. External resource
 URLs retain their complete query. Ordinary HTTP conditional caching is unchanged.
 
+Native-module packages mark component scripts with `data-arcane-packaged-script`
+and an external `src`. The loader executes those files through a real classic
+script element instead of fetching their text for inline execution. Each host
+receives its own invocation, `this` binding, ordered initialization, readiness
+and error events, cancellation, and imported `destroy()` restoration. Independent
+component hosts remain concurrent. Ordinary unmarked components retain their
+existing inline/fetched-script path.
+
 Exact exports: `default`.
 
 ### Availability and normalization
@@ -2534,6 +2543,40 @@ import * as module from '/arcane/modules/HTMLImport.js';
 console.log(Object.keys(module));
 ```
 
+## HTMLImportScript.js
+
+### Overview
+
+Renders the complete classic-script host wrapper shared by HTMLImport and
+native-module packaging. Rendering returns source text; it does not execute it
+or access the DOM.
+
+### Public surface
+
+`createHTMLImportScript(source)` returns the complete source inside the loader's
+async host-bound initializer. A newline separates the authored ending from the
+wrapper closure, including when the body ends in a line comment. At execution,
+the wrapper uses the current script's host token and the HTMLImport-owned
+registry, then exposes the initializer promise to that host's loader.
+
+Exact exports: `createHTMLImportScript`.
+
+### Availability and normalization
+
+**Cross-host.** Complete source retained with a terminating newline before the
+wrapper closes. Transport: In-process only. [Deep protocol details](protocols.md).
+
+### Example
+
+```javascript
+import {createHTMLImportScript} from 'arcane-os/modules/HTMLImportScript.js';
+
+const source=createHTMLImportScript('this.textContent="The moon burglar arrived.";');
+```
+
+Application packaging normally calls `packageApp({moduleFormat:'native', ...})`
+instead of assembling or executing component wrappers itself.
+
 ## InMemoryCommunicationProvider.js
 
 ### Overview

package/docs/reference/sdk-api.md

@@ -2,9 +2,10 @@
 
 The npm package exposes a Node.js ESM control plane, the portable
 `arcane-os/event-manager`, `arcane-os/logging`, `arcane-os/mail`,
-`arcane-os/preference-store`, `arcane-os/speech-playback`,
+`arcane-os/preference-store`, `arcane-os/speech-playback`, `arcane-os/websocket-client`,
 `arcane-os/speech-text`, `arcane-os/ai/tool-text-stream`, `arcane-os/ai/twin-cloud`, and `arcane-os/browser-device` entrypoints, and the browser-only
-`arcane-os/pwa` and `arcane-os/ai/browser-wasm` entrypoints. The
+`arcane-os/pwa`, `arcane-os/ai/browser-wasm`, and
+`arcane-os/ai/browser-decisions` entrypoints. The
 `arcane-os/ai/browser-speech` entrypoint includes local and native browser
 providers plus a cloud TTS adapter usable in Node with Fetch and Blob.
 The `arcane-os/modules/<filename>` and `arcane-os/entities/<filename>` paths
@@ -41,7 +42,8 @@ runtime layouts.
 | `arcane-os` | Complete high-level SDK surface. |
 | `arcane-os/toolchain` | Headless application operations. |
 | `arcane-os/events` | CLI/event reporter. |
-| `arcane-os/websocket` | Node HTTP/1.1 WebSocket Upgrade, complete messages and connection lifecycle. Browser clients use native `WebSocket`. |
+| `arcane-os/websocket` | Node HTTP/1.1 WebSocket Upgrade, complete messages and accepted connection lifecycle. |
+| `arcane-os/websocket-client` | Shared native client `WS`, one managed-connection observer and current connection snapshots through published ws-share. |
 | `arcane-os/testing` | Isolated test registration and execution. |
 | `arcane-os/targets` | Target adapters and dispatch. |
 | `arcane-os/native` | Native plan and builder protocol. |
@@ -74,6 +76,7 @@ runtime layouts.
 | `arcane-os/browser-device` | Synchronous mobile or desktop identity hints for application-owned settings. |
 | `arcane-os/pwa` | Nonblocking PWA registration, worker updates, native installation state and a dismissible installation component. |
 | `arcane-os/ai/browser-wasm` | Caller-selected browser-local Wllama inference, complete DBOPFS model storage, streaming, cancellation, and structural tool-call results. |
+| `arcane-os/ai/browser-decisions` | Explicit-load Laya FP16 and Julia-1 FP32 typed decisions through the shared Transformers.js Worker owner. |
 | `arcane-os/ai/tool-text-stream` | Shared selected tool-argument text observer for provider integration. |
 | `arcane-os/ai/twin-cloud` | Stateless chat, System One state/questions and image generation with explicit key/model, complete results and operation-specific retry/cancellation. |
 | `arcane-os/ai/browser-speech` | Caller-selected Whisper/Kokoro, native browser recognition/synthesis, cloud TTS, upstream assets, role lifecycle and cancellation. |
@@ -132,6 +135,8 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | Member | Kind | Import | Group | Availability |
 | --- | --- | --- | --- | --- |
 | `acceptWebSocket()` | function | `arcane-os`, `arcane-os/websocket` | WebSocket protocol | Node; browser-native client interoperability |
+| `WS` | class | `arcane-os`, `arcane-os/websocket-client` | Shared WebSocket clients | Node and native-WebSocket browser hosts |
+| `createBrowserDecisionModel()` | function | `arcane-os/ai/browser-decisions` | Browser typed decisions | Browser module Workers and the caller-selected inference backend |
 | `fetchRequest()` | function | `arcane-os/ai/twin-cloud` | TWiN Cloud requests | Node and Browser; remote HTTPS provider |
 | `fetchSystemOneRequest()` | function | `arcane-os/ai/twin-cloud` | TWiN Cloud state-and-questions requests | Node and Browser; remote HTTPS provider |
 | `generateImages()` | function | `arcane-os/ai/twin-cloud` | TWiN Cloud image generation | Node and Browser with Fetch and Blob; remote HTTPS provider |
@@ -868,6 +873,42 @@ The package preserves the complete selected content, applying the documented
 asset-version and enabled browser-PWA transformations to resource references.
 Malformed configuration or descriptors fail while preserving the prior output.
 
+`moduleFormat` defaults to `'import-map'`, preserving the ordinary browser
+package. Select `'native'` to resolve saved document import maps into native
+module URLs in the package stage and emit executable inline scripts as external
+files. Static imports, re-exports, string-literal dynamic imports and
+string-literal `import.meta.resolve()` retain exact/prefix/scoped mappings.
+Imported HTML components use the shared `HTMLImport` externally executable
+script path, retaining their host binding and asynchronous lifecycle. No
+application-owned module loader is needed. Source HTML, saved data and the
+ordinary browser output remain unchanged. See
+[native-module package output](protocols.md#native-module-package-output)
+for resource handling and the static transformation boundary.
+
+An operation may override `outputDirectory` without changing the saved app
+configuration. For example, package a complete application beneath an
+application-owned extension manifest and launcher:
+
+```javascript
+const release = await packageApp({
+    workspaceRoot,
+    appId: 'moon-dashboard',
+    outputDirectory: 'dist/extension/app',
+    moduleFormat: 'native',
+    browserPwa: false
+});
+```
+
+The override uses the same workspace-relative destination and staged replacement
+rules as the saved field. It replaces only `dist/extension/app`, leaving its
+extension-root siblings and an existing browser output intact. `browserPwa:false`
+omits generated PWA artifacts for this invocation; it does not change the app's
+saved PWA configuration. The app owns extension metadata, permissions and toolbar
+launch behavior. This API builds the application directory, not an extension
+manifest or an operating-system launcher. Native-mode dry runs report selected
+input files; generated script/context files are included in the completed
+package's full returned inventory.
+
 The app's optional schema-1 `outputDirectory` selects the final
 workspace-relative destination. For example, `"ai"` emits directly into
 `<workspace>/ai`; omission retains `dist/<app-id>`. The selected directory is
@@ -1151,11 +1192,14 @@ Authenticates one existing browser app release through the low-level packager AP
 ### Signature and result
 
 ```text
-async verifyApp({workspaceRoot, appId, signal, onEvent})
+async verifyApp({workspaceRoot, appId, outputDirectory, signal, onEvent})
 ```
 
 Import it from `arcane-os` or `arcane-os/packager`. The signature above states whether settlement is synchronous or promise-based. The overview and owning group define result authority, side effects, callbacks, events, cancellation, and lifecycle.
 
+Optional `outputDirectory` selects the same workspace-relative override accepted
+by `packageApp`, without changing the app's saved destination.
+
 ### Availability and normalization
 
 **Node.** Normalized SDK validation with complete canonical archive and release content. Deep protocol: [SDK packager and deterministic bundle contract](protocols.md).
@@ -1304,14 +1348,16 @@ The resolved result contains:
     runtimeRoot,
     documentPaths,
     documentCount,
-    documents: [{path, filePath, imports}],
+    documents: [{path, filePath, imports, scopes?}],
     committed: true
 }
 ```
 
 `documentPaths` and each `filePath` are absolute filesystem paths. Each `path`
-is relative to `documentRoot`; `imports` is the complete map rendered for that
-document. The operation inventories the runtime once, builds the shared map
+is relative to `documentRoot`; `imports` contains the global bindings rendered
+for that document. Optional `scopes` contains dependency-specific bindings;
+scope URLs and their targets are rebased with the same document base as global
+imports. The operation inventories the runtime once, builds the shared map
 once, and reads the selected documents with up to four concurrent readers.
 It renders every document before writing any of them, then writes in selected
 order. `committed: true` means all selected writes completed; the batch is not
@@ -3755,6 +3801,22 @@ async function useselectApp(...arguments_) {
 }
 ```
 
+## WS
+
+Import `WS` as the default or named binding from `arcane-os/websocket-client`,
+or as a named binding from the Node root `arcane-os`. `new WS(uri,protocols?)`
+returns the exact native socket from published ws-share, sharing a connecting
+or open socket for the same exact URI string and ordered protocol list.
+`await WS.observe()` exposes one event-pubsub observer with
+`created`/`open`/`error`/`close` lifecycle records; `WS.getConnections()` returns
+current managed-connection snapshots. Each physical connection has its own ID,
+including replacements at the same address.
+
+The [shared-client guide](websocket-client.md) covers complete record fields,
+subscribe-then-snapshot ordering, listener cleanup, shared close ownership,
+native per-socket behavior and the per-loaded-module/realm boundary. This
+client entry does not change the server-side `acceptWebSocket` contract.
+
 ## acceptWebSocket()
 
 ### Overview
@@ -3766,8 +3828,9 @@ the public `.server` / `.secureServer` of `node-http-server`. There is no
 listener creation, default port, application envelope, message persistence,
 client sharing, reconnect loop or third-party WebSocket runtime.
 
-Browser clients use native `WebSocket` directly. Node's global `WebSocket` is
-also a client, not a server. This server adapter supports version 13 over an
+Clients may use native `WebSocket` directly or the separate shared
+[`WS` client](websocket-client.md). Node's global `WebSocket` is also a client,
+not a server. This server adapter supports version 13 over an
 HTTP/1.1 `upgrade` event, including HTTP/1.1 negotiated on an HTTPS listener.
 It does not implement HTTP/2 extended CONNECT or negotiate extensions such as
 compression. TLS setup remains with the existing server owner.
@@ -6819,6 +6882,67 @@ See the [mounting contract](pwa.md#mountpwainstallprompt) and
 [component reference](runtime-components.md#pwa-installhtml). The browser owns
 native installation eligibility and URL-bar promotion.
 
+## createBrowserDecisionModel()
+
+### Overview
+
+Creates an explicitly loaded browser model for Laya typed decisions in FP16 or
+Julia-1 in FP32. The shared Worker owns Transformers.js loading, full-input
+encoding, batched inference, complete results, cancellation and resource lifetime.
+Applications own model selection, questions, option meanings and decision policy.
+Existing chat and speech providers are unchanged.
+
+### Signature and result
+
+```js
+import {createBrowserDecisionModel} from 'arcane-os/ai/browser-decisions';
+
+const decisions = createBrowserDecisionModel(
+    {
+        family: 'laya',
+        model: 'onnx-community/laya-typed-decisions-ONNX',
+        device: 'webgpu'
+    }
+);
+```
+
+Construction starts no model download. The returned client exposes
+`load({signal})`, `evaluate(rows, {signal})`, `status()`,
+`subscribe(listener, {emitCurrent: true, signal})`, `unload()` and `dispose()`.
+Each row contains its complete `state`, `question`, string `options`, and
+optional `type` (`choice`, `score`, or `noul`). `evaluate()` returns
+`{decisions, outputs}` with all graph outputs and raw, unrounded probabilities.
+See the [complete browser decision contract](ai/browser-decisions.md) for
+precision, tokenization, output meanings, lifecycle and model limitations.
+
+### Availability and normalization
+
+Browser module Workers plus the selected Transformers.js backend are required
+on explicit use. Import and construction do not activate a model. Laya fixes
+`dtype: 'fp16'`; Julia fixes `dtype: 'fp32'`; there is no precision fallback.
+Cancellation terminates that client's Worker and rejects its in-flight work.
+No decisions are inserted into chat history or durable storage.
+
+### Example
+
+```js
+runButton.addEventListener(
+    'click',
+    async function askTeaRobot() {
+        const result = await decisions.evaluate(
+            [
+                {
+                    state: 'The dragon is asleep. The tea robot has a very loud kettle.',
+                    question: 'Should the robot boil tea now?',
+                    options: ['Wait quietly', 'Boil the kettle']
+                }
+            ]
+        );
+        output.textContent = result.decisions[0].value;
+    }
+);
+```
+
 ## createBrowserWasmLlmProvider()
 
 ### Overview

package/docs/reference/websocket-client.md

@@ -0,0 +1,132 @@
+# Shared WebSocket clients
+
+`arcane-os/websocket-client` exposes the published `ws-share` constructor as
+both `default` and `WS`. Node also exports the same `WS` binding from
+`arcane-os`. Browser modules use the focused entry through the generated SDK
+import map. These entries reuse the upstream implementation rather than
+creating another pool or event bus.
+
+```javascript
+import WS from 'arcane-os/websocket-client';
+
+const airlock=new WS('wss://moon.example/airlock',['moon-control']);
+const oxygenPanel=new WS('wss://moon.example/airlock',['moon-control']);
+console.log(airlock===oxygenPanel); // true while connecting or open
+
+function showAirlockMessage(event){
+    console.log(event.data);
+}
+airlock.addEventListener('message',showAirlockMessage);
+
+// When this panel goes away, release only its listener.
+function disposePanel(){
+    airlock.removeEventListener('message',showAirlockMessage);
+}
+```
+
+Replace the example URL with your application's WebSocket endpoint. The exact
+URI string and ordered protocol list select a shared connection. Repeated
+construction reuses a connecting or open socket. A closing or closed socket
+gets a new physical connection and a new ID; the predecessor's eventual close
+cannot remove its replacement.
+
+The returned object is the native `WebSocket`, with its native `send`,
+`close`, `binaryType`, properties and per-socket events. Complete messages pass
+through unchanged. Upstream `on`/`off` and `addListener`/`removeListener`
+aliases retain native listener semantics, rather than Node EventEmitter
+semantics. Importing the SDK entry starts no connection and does not replace
+`globalThis.WebSocket`.
+
+## Observe all managed connections
+
+`await WS.observe()` returns one lazy `event-pubsub` observer per loaded
+implementation. Repeated or concurrent calls return that same observer.
+Enabling observation opens no socket. Register handlers after the await, then
+read `WS.getConnections()` synchronously without another await between them.
+
+```javascript
+import {WS} from 'arcane-os/websocket-client';
+
+const events=await WS.observe();
+const liveConnections=new Map();
+
+function trackConnection(type,connection){
+    if(type==='close')liveConnections.delete(connection.id);
+    else liveConnections.set(connection.id,connection);
+    console.log(type,connection.id,connection.url,connection.readyState);
+}
+
+events.on('*',trackConnection);
+for(const connection of WS.getConnections()){
+    liveConnections.set(connection.id,connection);
+}
+
+function disposeConnectionPanel(){
+    events.off('*',trackConnection);
+}
+```
+
+The typed events `created`, `open`, `error` and `close` each receive one record.
+The wildcard handler receives `(type,record)`. Each record contains:
+
+| Field | Meaning |
+| --- | --- |
+| `id` | Numeric physical-connection identity within this loaded implementation. |
+| `socket` | The exact native socket. |
+| `url` | The native socket's URL. |
+| `protocols` | A fresh copy of the requested, normalized protocol list. |
+| `readyState` | Native state when the record is produced. |
+| `event` | Original native event; `created` has `undefined`. |
+
+`WS.getConnections()` returns fresh records with the first five fields. It
+includes tracked sockets until their native close event, including a closing
+predecessor after its replacement exists. Records are snapshots; the `socket`
+remains live. Read a new snapshot when current state is needed.
+
+`created` is queued in a microtask only when observation was enabled at
+construction. Reusing a connection emits no second `created` event. A snapshot
+can include a connection before its queued `created` notification arrives, so
+reconcile by `id` rather than appending duplicates. Native close removes the
+connection and its internal lifecycle listeners before global close handlers
+run. Applications may still use native socket listeners alongside the global
+observer; there is no second per-socket event bus.
+
+## Ownership and lifetime
+
+Every caller shares the same socket, including changes to `binaryType`, a
+property handler, or a call to `close()`. A component that only owns a listener
+removes that exact listener. The application decides when the shared socket
+should close; construction does not acquire an independent reference-counted
+lifetime. Remove only your own observer handlers instead of resetting the
+shared observer. Observe asynchronous handler failures at their owning caller.
+
+All modules that should share connections use the same SDK module URL in
+their realm. Separate package copies, browser realms, Workers, processes, and
+upstream classic-script versus ESM loads have separate pools. The observer
+reports actual native lifecycle events; it provides no closed-event history
+or delivery after the realm/process ends. It adds no automatic reconnect,
+heartbeat, message envelope, storage, or application routing.
+
+## Runtime and package delivery
+
+The SDK's Node baseline supplies native `WebSocket`; browsers need their native
+WebSocket capability. The focused entry is portable JavaScript, with the host
+owning networking and native errors. Browser Workers need module resolution
+provided by their host because document import maps do not apply to Workers.
+
+The SDK selects `ws-share@3.1.0` and `event-pubsub@6.1.1`. npm resolves the
+latter's `strong-type@2.0.0`, while the SDK's own direct `strong-type@2.0.1`
+remains unchanged. The canonical browser projection generator copies the
+installed public runtime files unchanged. Managed maps resolve the shared
+constructor and event package to one URL each, and a dependency scope selects
+the event package's own strong-type version. Physical, direct-installed,
+packaged-document and managed test maps preserve that scope. Applications
+regenerate their managed maps/runtime through the ordinary public SDK flow;
+they do not copy the upstream implementation into application source.
+
+`acceptWebSocket` remains the separate Node server-side API at
+`arcane-os/websocket`. It owns accepted server connections, not this client
+pool. Existing native clients and server Upgrade handling remain available.
+
+Upstream details: [ws-share 3.1.0 release](https://github.com/RIAEvangelist/ws-share/releases/tag/3.1.0)
+and [observer documentation](https://riaevangelist.github.io/ws-share/#observe).

package/node_modules/event-pubsub/CHANGELOG.md

@@ -1,8 +1,19 @@
 # Changelog
 
+## 6.1.1 — 2026-08-23
+
+- Replaced the consumer-root-relative `../strong-type/index.js` import with the bare `strong-type` package name so Node selects event-pubsub's declared nested exact dependency under a root version conflict.
+- Declared the shared `index.js` source as the explicit browser entry and made bundled plus no-build unbundled support explicit, including normal and conflict-scoped import maps.
+- Added a packed-consumer regression that installs `strong-type` 1.1.0 at the consumer root, poisons that copy, instruments event-pubsub's nested 2.0.0, and proves both ESM and CommonJS execute the nested validator.
+- Added packed real-Chrome consumers for the normal and conflict-scoped import maps plus a Rollup 4.62.5/node-resolve 16.0.3 bundle of the poisoned conflict layout.
+- Staged the exact validator beneath event-pubsub and made the shared Chrome suite and live playgrounds resolve the bare `event-pubsub` and `strong-type` names through explicit maps.
+- Added a 12-scenario Behavioral suite with Given/When/Then consumer workflows for audited delivery, nested events, lifecycle teardown, routing, synchronous replies, shared payloads, failure propagation, asynchronous side effects, live subscriber changes, and hub isolation.
+- Expanded the shared host-neutral Node/Chrome registry to 131 checks and added the focused `npm run test:behavioral` command.
+- Added a focused Behavioral inventory page and carried the 131-check total through CI, coverage, status, and deployment validation.
+
 ## 6.1.0 — 2026-08-21
 
-Published to npm as the current registry release from the verified `main` source. No separate 6.1.0 GitHub tag or release was created.
+Published to npm and GitHub from the same verified source commit.
 
 - Added direct CommonJS `require('event-pubsub')` support while keeping one native ESM implementation for both module systems.
 

package/node_modules/event-pubsub/MIGRATION.md

@@ -1,6 +1,6 @@
 # Migrating from event-pubsub 5.x to 6.x
 
-Version 6 preserves the public method names and synchronous wildcard-first model while formalizing previously inconsistent edge behavior. The 6.1.0 npm release restores the original delegated validation and package layout while adding shared-source CommonJS consumption.
+Version 6 preserves the public method names and synchronous wildcard-first model while formalizing previously inconsistent edge behavior. The 6.1.0 npm release restored delegated validation and shared-source CommonJS consumption. The 6.1.1 correction makes Node resolve that validator through event-pubsub's declared dependency boundary.
 
 ## Requirements
 
@@ -23,7 +23,7 @@ Version 6 preserves the public method names and synchronous wildcard-first model
 
 ### Package layout
 
-The package keeps its historical ESM entry at `event-pubsub/index.js` without a restrictive export map. Applications should normally import `event-pubsub`; repository-only paths are not part of the supported API.
+The package keeps its historical ESM entry at `event-pubsub/index.js` without a restrictive export map and declares that same source as its browser entry. Applications should normally import `event-pubsub`; repository-only paths are not part of the supported API.
 
 ## Behavior to review
 
@@ -53,15 +53,18 @@ Public argument checks again come from `strong-type` 2.0.0. Invalid inputs still
 
 Each `list` access creates a null-prototype object with copied handler arrays. Mutating or deleting snapshot values no longer mutates the live registry. Use `Object.hasOwn(snapshot, type)` instead of calling `snapshot.hasOwnProperty(...)`. The wildcard entry remains available through `Symbol.for('event-pubsub-all')`.
 
-### Browser package imports
+### Package dependency resolution
 
-The 6.1.0 release restores `strong-type` 2.0.0 as the sole production dependency and preserves the deliberate `../strong-type/index.js` include shim. Node installs both packages as siblings. For an unbundled browser, serve the same sibling directories and map the public `event-pubsub` name to its `index.js`; the relative validator import then resolves without a second package-name mapping.
+The 6.1.0 entry reached `strong-type` through `../strong-type/index.js`. In a consumer with an incompatible root validator and event-pubsub's exact 2.0.0 nested beneath it, that relative path could execute the root package. The 6.1.1 entry uses the bare `strong-type` name, so Node and bundlers resolve from event-pubsub outward and select its nested declared dependency first.
+
+Browser support is explicit in both modes: bundlers resolve both package names normally, while unbundled native ESM runs the same source directly with an import map and no build step. Native browsers do not read the npm `browser` field. Put the map before the first module script, serve the app over HTTP(S), and map both `event-pubsub` and `strong-type`. When npm nests event-pubsub's validator because the root version conflicts, add an import-map scope for `./node_modules/event-pubsub/` that maps `strong-type` to `./node_modules/event-pubsub/node_modules/strong-type/index.js`. The README contains complete hoisted and conflicting-layout examples, both exercised from a packed install in real Chrome.
 
 ## Tooling cleanup
 
 - `vanilla-test` is now pinned exactly at 2.1.1.
+- Rollup 4.62.5 with node-resolve 16.0.3 is exact-pinned and configured only for JavaScript as the bundled-browser conformance probe.
 - Native Node and Chrome coverage replaces c8.
-- The old `copyfiles` dependency is gone; a dependency-free staging script now verifies the package-shaped Node/browser layout.
+- The old `copyfiles` dependency is gone; a dependency-free staging script now verifies the nested exact dependency in Node and maps that same copy for browser coverage.
 - `copyfiles`, `c8`, and the test-only `node-http-server` dependency are removed.
 - Production installs contain exactly one dependency: `strong-type` 2.0.0. They do not install `copyfiles` or the development-only `vanilla-test`.