arcane-os 0.13.3 → 0.15.0

package/browser-runtime/ai/tool-text-stream.mjs

@@ -0,0 +1,364 @@
+import Is from '../dependencies/strong-type/index.js';
+
+const is = new Is(false);
+const STRING_ESCAPES = {
+    '"': '"',
+    '\\': '\\',
+    '/': '/',
+    b: '\b',
+    f: '\f',
+    n: '\n',
+    r: '\r',
+    t: '\t'
+};
+
+function projectionError(message, cause) {
+    const error = new SyntaxError(
+        `Tool text projection ${message}`,
+        cause === undefined ? undefined : {cause}
+    );
+    error.code = 'ARCANE_AI_TOOL_TEXT_INVALID';
+    return error;
+}
+
+function isWhitespace(character) {
+    return character === ' ' || character === '\t'
+        || character === '\n' || character === '\r';
+}
+
+function createArgumentScanner(field, appendText, beginText, endText) {
+    const stack = [];
+    let started = false;
+    let finished = false;
+    let string = null;
+    let scalar = null;
+
+    function finishValue() {
+        stack[stack.length - 1].state = 'commaOrEnd';
+    }
+
+    function closeContainer() {
+        stack.pop();
+        if (stack.length) {
+            finishValue();
+        } else {
+            finished = true;
+        }
+    }
+
+    function acceptStringCharacter(character) {
+        if (string.key) {
+            if (stack.length === 1) string.value += character;
+        } else if (string.selected) {
+            appendText(character, string.offset);
+            string.offset += character.length;
+        }
+    }
+
+    function readStringCharacter(character) {
+        if (string.unicode !== null) {
+            if (!/[0-9a-fA-F]/.test(character)) {
+                throw projectionError('encountered an invalid Unicode escape.');
+            }
+            string.unicode += character;
+            if (string.unicode.length === 4) {
+                acceptStringCharacter(
+                    String.fromCharCode(Number.parseInt(string.unicode, 16))
+                );
+                string.unicode = null;
+            }
+            return;
+        }
+        if (string.escaped) {
+            string.escaped = false;
+            if (character === 'u') {
+                string.unicode = '';
+            } else if (Object.hasOwn(STRING_ESCAPES, character)) {
+                acceptStringCharacter(STRING_ESCAPES[character]);
+            } else {
+                throw projectionError('encountered an invalid string escape.');
+            }
+            return;
+        }
+        if (character === '\\') {
+            string.escaped = true;
+        } else if (character === '"') {
+            const frame = stack[stack.length - 1];
+            if (string.key) {
+                frame.key = string.value;
+                frame.state = 'colon';
+            } else {
+                if (string.selected) endText(string.offset);
+                finishValue();
+            }
+            string = null;
+        } else {
+            if (character.charCodeAt(0) < 32) {
+                throw projectionError('encountered an unescaped control character.');
+            }
+            acceptStringCharacter(character);
+        }
+    }
+
+    function startString(key, selected = false) {
+        string = {key, selected, value: '', offset: 0, escaped: false, unicode: null};
+        if (selected) beginText();
+    }
+
+    function startValue(character, frame) {
+        const selected = stack.length === 1 && frame.kind === 'object'
+            && frame.key === field;
+        if (selected && character !== '"') {
+            beginText();
+            endText(0);
+        }
+        if (character === '"') {
+            startString(false, selected);
+        } else if (character === '{') {
+            stack.push(
+                {kind: 'object', state: 'keyOrEnd', key: ''}
+            );
+        } else if (character === '[') {
+            stack.push(
+                {kind: 'array', state: 'valueOrEnd'}
+            );
+        } else if (character === '-' || character >= '0' && character <= '9'
+            || character === 't' || character === 'f' || character === 'n') {
+            scalar = character;
+        } else {
+            throw projectionError('encountered an invalid argument value.');
+        }
+    }
+
+    function appendArguments(fragment) {
+        for (let position = 0; position < fragment.length; position += 1) {
+            const character = fragment[position];
+            if (string) {
+                readStringCharacter(character);
+                continue;
+            }
+            if (scalar !== null) {
+                if (!isWhitespace(character) && character !== ','
+                    && character !== '}' && character !== ']') {
+                    scalar += character;
+                    continue;
+                }
+                try {
+                    JSON.parse(scalar);
+                } catch (cause) {
+                    throw projectionError('encountered an invalid argument value.', cause);
+                }
+                scalar = null;
+                finishValue();
+            }
+            if (isWhitespace(character)) continue;
+            if (finished) {
+                throw projectionError('encountered content after the argument object.');
+            }
+            if (!started) {
+                if (character !== '{') {
+                    throw projectionError('requires a root argument object.');
+                }
+                started = true;
+                stack.push(
+                    {kind: 'object', state: 'keyOrEnd', key: ''}
+                );
+                continue;
+            }
+            const frame = stack[stack.length - 1];
+            if (frame.state === 'keyOrEnd' || frame.state === 'key') {
+                if (character === '"') {
+                    startString(true);
+                } else if (character === '}' && frame.state === 'keyOrEnd') {
+                    closeContainer();
+                } else {
+                    throw projectionError('encountered an invalid object key.');
+                }
+            } else if (frame.state === 'colon') {
+                if (character !== ':') {
+                    throw projectionError('expected a colon after an object key.');
+                }
+                frame.state = 'value';
+            } else if (frame.state === 'value' || frame.state === 'valueOrEnd') {
+                if (character === ']' && frame.state === 'valueOrEnd') {
+                    closeContainer();
+                } else {
+                    startValue(character, frame);
+                }
+            } else if (character === ',') {
+                frame.state = frame.kind === 'object' ? 'key' : 'value';
+            } else if (character === (frame.kind === 'object' ? '}' : ']')) {
+                closeContainer();
+            } else {
+                throw projectionError('expected a comma or the end of an argument container.');
+            }
+        }
+    }
+
+    return appendArguments;
+}
+
+export function createToolTextObserver(selection, onText, {signal} = {}) {
+    if (selection === undefined || selection === null || selection === false) return null;
+    if (!is.object(selection) || is.array(selection)
+        || !is.string(selection.name) || !selection.name.trim()
+        || !is.string(selection.field) || !selection.field.trim()) {
+        throw new TypeError('AI toolText must name a tool and a root string field.');
+    }
+    if (!is.function(onText)) {
+        throw new TypeError('AI onToolText must be a function when toolText is selected.');
+    }
+    const name = selection.name;
+    const field = selection.field;
+    const choices = new Map();
+
+    function recordFor(choiceIndex, index) {
+        let calls = choices.get(choiceIndex);
+        if (!calls) {
+            calls = new Map();
+            choices.set(choiceIndex, calls);
+        }
+        let record = calls.get(index);
+        if (!record) {
+            record = {
+                id: '', name: '', index, choiceIndex, pending: [], scanner: null,
+                text: '', emitted: 0, textOpen: false
+            };
+            calls.set(index, record);
+        }
+        return record;
+    }
+
+    function prepareScanner(record) {
+        if (!record.scanner) {
+            record.scanner = createArgumentScanner(
+                field,
+                function appendSelectedToolText(text, offset) {
+                    for (let index = 0; index < text.length; index += 1) {
+                        const position = offset + index;
+                        if (position < record.text.length) {
+                            if (record.text[position] !== text[index]) {
+                                throw projectionError('received conflicting selected argument text.');
+                            }
+                        } else {
+                            record.text += text[index];
+                        }
+                    }
+                },
+                function beginSelectedToolText() {
+                    if (record.emitted === 0) record.text = '';
+                    record.textOpen = true;
+                },
+                function finishSelectedToolText(length) {
+                    if (length < record.text.length) {
+                        throw projectionError('received a shorter replacement for selected argument text.');
+                    }
+                    record.textOpen = false;
+                }
+            );
+        }
+        for (const fragment of record.pending) record.scanner(fragment);
+        record.pending = [];
+    }
+
+    function observeCompleteArguments(record, argumentsValue) {
+        let argumentsObject = argumentsValue;
+        if (is.string(argumentsObject)) {
+            try {
+                argumentsObject = JSON.parse(argumentsObject);
+            } catch (cause) {
+                throw projectionError('received invalid complete argument JSON.', cause);
+            }
+        }
+        if (!argumentsObject || !is.object(argumentsObject) || is.array(argumentsObject)) {
+            throw projectionError('requires a complete argument object.');
+        }
+        if (!Object.hasOwn(argumentsObject, field)) {
+            if (record.emitted > 0) {
+                throw projectionError('lost the selected argument field in a complete response.');
+            }
+            record.text = '';
+            record.textOpen = false;
+            return;
+        }
+        const text = argumentsObject[field];
+        if (!is.string(text)) {
+            throw projectionError('requires the selected argument field to be a string.');
+        }
+        // A terminal snapshot may repeat a complete value already streamed.
+        if (record.emitted > 0 && !text.startsWith(record.text)) {
+            throw projectionError('received conflicting complete argument text.');
+        }
+        record.text = text;
+        record.textOpen = false;
+    }
+
+    async function emitSelectedText(record) {
+        if (signal?.aborted || record.name !== name || !record.id) return;
+        let end = record.text.length;
+        if (record.textOpen && end > record.emitted) {
+            // Keep a split surrogate pair together without changing its code units.
+            const last = record.text.charCodeAt(end - 1);
+            if (last >= 0xD800 && last <= 0xDBFF) end -= 1;
+        }
+        if (end <= record.emitted) return;
+        const text = record.text.slice(record.emitted, end);
+        record.emitted = end;
+        await onText(
+            text,
+            {id: record.id, name: record.name, field, index: record.index, choiceIndex: record.choiceIndex}
+        );
+    }
+
+    async function observeCalls(calls, choiceIndex, complete) {
+        if (!is.array(calls)) return;
+        for (let position = 0; position < calls.length; position += 1) {
+            if (signal?.aborted) return;
+            const call = calls[position];
+            if (!call || !is.object(call)) continue;
+            const record = recordFor(choiceIndex, call.index ?? position);
+            if (is.string(call.id) && call.id) {
+                if (record.emitted && record.id !== call.id) {
+                    throw projectionError('changed the identity of a displayed tool call.');
+                }
+                record.id = call.id;
+            }
+            const functionValue = call.function && is.object(call.function)
+                ? call.function
+                : {};
+            if (is.string(functionValue.name)) {
+                const nextName = complete ? functionValue.name : record.name + functionValue.name;
+                if (record.emitted && nextName !== record.name) {
+                    throw projectionError('changed the name of a displayed tool call.');
+                }
+                record.name = nextName;
+            }
+            if (!name.startsWith(record.name)) {
+                record.pending = [];
+                continue;
+            }
+            if (!complete && is.string(functionValue.arguments)) {
+                record.pending.push(functionValue.arguments);
+            }
+            if (record.name !== name) continue;
+            prepareScanner(record);
+            if (complete) observeCompleteArguments(record, functionValue.arguments);
+            await emitSelectedText(record);
+        }
+    }
+
+    return async function observeToolText(chunk) {
+        if (signal?.aborted || !chunk || !is.object(chunk)) return;
+        if (is.array(chunk.choices)) {
+            for (let position = 0; position < chunk.choices.length; position += 1) {
+                if (signal?.aborted) return;
+                const choice = chunk.choices[position];
+                if (!choice || !is.object(choice)) continue;
+                const choiceIndex = choice.index ?? position;
+                await observeCalls(choice.delta?.tool_calls, choiceIndex, false);
+                await observeCalls(choice.message?.tool_calls, choiceIndex, true);
+            }
+        }
+        if (!signal?.aborted) await observeCalls(chunk.message?.tool_calls, 0, true);
+    };
+}

package/docs/architecture.md

@@ -136,8 +136,8 @@ selected source route and the last successful check when evaluating freshness.
 
 The shared dev server uses RIAEvangelist's `node-http-server` public interface
 for HTTPS and conditional responses on those selected routes. The SDK
-owns source selection and generated representations. Every Arcane development
-server and packaged browser preview serves content on HTTPS and redirects its
+owns source selection and generated representations. By default, source development
+and every packaged browser preview serve content on HTTPS and redirect their
 paired HTTP listener with status 308 through the public request hook.
 `arcane dev --public` selects the IPv4 wildcard address;
 explicit `--host` controls the bind address. CLI startup reads one workspace-local
@@ -151,6 +151,14 @@ redirect listener, defaulting to an OS-assigned port. Existing raw `tls` inputs
 retain their native HTTPS transport under the SDK, as described by the module's
 advanced TLS extension guidance; all content uses its public serving methods.
 
+Explicit `arcane dev --http` or source API `http:true` selects the module's
+single HTTP listener on `port`. It skips certificate resolution and serves the
+same selected source mappings, generated PWA routes, and conditional responses.
+No HTTPS listener or redirect is started in this mode. Listener readiness,
+failure, cancellation and shutdown retain the same operation owner; reported
+URLs use the actual HTTP protocol and bound port. Browser secure-context
+requirements remain browser-owned. Packaged previews retain HTTPS.
+
 Development is an intentionally fast feedback loop. Keep each increment small
 and independently understandable so its effect has one clear cause and a
 mistake can be isolated without untangling unrelated work. A development

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

@@ -320,6 +320,68 @@ Ordinary iteration exposes only text/reasoning chunks; raw structural deltas
 remain internal until the complete terminal result validates. Explicit
 `onResponse` or inspection consumers retain the complete raw terminal response.
 
+## Stream selected tool text
+
+Both `AI.streamRequest()` and this browser controller's `streamRequest()` accept
+`toolText:{name,field}` with `onToolText(text,call,displayId)`. Select the exact
+tool name and one root-level string argument. The callback receives newly
+decoded text in arrival order, preserving whitespace and JSON string escapes as
+their original characters. Its `call` record is
+`{id,name,field,index,choiceIndex}`: the actual normalized tool-call ID, matching
+tool name, selected field, call index within the response choice, and choice
+index. Delivery waits until the matching name and ID are known. `displayId` is
+the request's existing `M-${id}` display ID.
+
+This callback is distinct from ordinary `onChunk`; display the text in the
+corresponding tool turn and keep ordinary prose in its own existing turn.
+`onToolCall` still receives only the complete normalized call after terminal
+settlement. The text callback does not execute a tool, rewrite arguments, or
+retain a transcript. The application owns the completed call's execution and
+stores its complete visible result once through its normal history path.
+If a provider supplies arguments only at completion, the callback runs only
+when that actual complete response arrives. Repeated terminal snapshots do not
+replay text already emitted. Callback errors reach the request owner, and a
+cancelled or superseded request stops further text delivery.
+
+For example, an application that already supplies a closing-report tool can
+connect its existing display operations without parsing provider protocol:
+
+```javascript
+import {
+    formatConversationClosingReportText
+} from '/arcane/modules/ConversationClosingReport.js';
+
+async function streamClosingReport(ai, messages, closingTool, view, signal) {
+    return ai.streamRequest(
+        {
+            messages,
+            tools:[closingTool],
+            signal,
+            toolText:{name:closingTool.function.name, field:'final_message'},
+            onChunk:function appendOrdinaryText(text, displayId, thinking) {
+                return view.appendAssistantText(text, displayId, thinking);
+            },
+            onToolText:function appendClosingText(text, call, displayId) {
+                return view.appendToolText(
+                    formatConversationClosingReportText(text),
+                    call.id,
+                    displayId
+                );
+            }
+        }
+    );
+}
+```
+
+The application supplies `view` and the existing `closingTool`; those are not
+SDK exports. The formatter applies the same existing `&`, `<`, and `>` escaping
+used for the complete closing report, including whitespace-only chunks. The
+returned terminal call remains available to the application's normal tool
+execution and persistence path. These options do not change the tool schema,
+tool choice, or authored request content. Omitting `toolText` creates no text
+observer. Invalid selection or callback input throws `TypeError`; malformed
+selected argument text reports `ARCANE_AI_TOOL_TEXT_INVALID`.
+
 ## Errors and unavailable states
 
 Invalid configuration can throw `TypeError` or `RangeError`. Operational

package/docs/reference/cli.md

@@ -50,8 +50,9 @@ meaning and cardinality rules:
 | `--arcane-root` | directory | `doctor`, native `build`/`run`, `native-doctor`, `native-prepare` |
 | `--host` / `--port` | host / integer 0–65535 | Browser `dev`/`run` default to HTTPS at `127.0.0.1:8000`; `mail serve` defaults to HTTP at `127.0.0.1:8025` and admits numeric loopback only. |
 | `--http-port` | integer 0–65535 | Browser `dev`/`run` HTTP redirect listener; defaults to `0`, which selects an available port. |
-| `--public` | flag | `dev`; serves HTTPS and binds to `0.0.0.0` unless `--host` explicitly selects another address. |
-| `--https` | flag | Browser `dev`/`run`; retained explicitly, while HTTPS is always enabled. |
+| `--public` | flag | `dev`; binds to `0.0.0.0` unless `--host` explicitly selects another address. |
+| `--http` | flag | `dev` only; serves source and PWA routes on one HTTP listener selected by `--port`, without TLS. |
+| `--https` | flag | Browser `dev`/`run`; explicitly selects the default HTTPS transport. |
 | `--cert` / `--key` | PEM file paths | Browser `dev`/`run`; supply both for an explicit certificate chain and private key. Relative paths resolve from the workspace. |
 | `--target` | target id | `new`, `init`, native diagnostics, `build`, `run` |
 | `--format` / `--signing` | target-supported values | Native diagnostics, `build`, `run` |
@@ -313,7 +314,7 @@ npm exec -- arcane upgrade --workspace . --app hello-world
 
 Starts one development server for one selected app and maps the exact
 workspace/runtime routes. It defaults to HTTPS on localhost; `--public` enables access
-from other devices on the network over HTTPS.
+from other devices on the network, using HTTPS by default.
 
 For an external workspace, the server exposes the selected projected
 `arcane/` root, including `arcane/sdk` and `arcane/dependencies`, alongside the
@@ -322,7 +323,7 @@ The explicit live-source SDK mapping remains unchanged and does not replace the
 installed projection.
 
 ```text
-arcane dev [--app <id>] [--public] [--https] [--cert <file> --key <file>] [--host <address>] [--port 8000] [--http-port 0]
+arcane dev [--app <id>] [--public] [--http | --https] [--cert <file> --key <file>] [--host <address>] [--port 8000] [--http-port 0]
 ```
 
 ### Lifecycle
@@ -344,7 +345,7 @@ device, since `localhost` refers to that device and `0.0.0.0` is a bind address.
 Network URLs come from one interface snapshot at startup and do not establish
 remote reachability through the machine's firewall or network.
 
-Every Arcane app uses HTTPS for development and packaged browser previews.
+HTTPS is the default for development and required for packaged browser previews.
 `--https` remains accepted but is no longer needed to select the transport.
 `--port` selects the HTTPS application port. A second HTTP listener returns
 `308` redirects to that HTTPS port, preserving the requested path and query.
@@ -357,9 +358,41 @@ the redirect endpoint.
 Supplying both `--cert` and `--key` selects an explicit PEM pair. The command
 does not configure a firewall, router forwarding, or an internet tunnel.
 
+### Explicit HTTP development
+
+`--http` selects source development over HTTP. Combine it with `--public` or
+`--host` to use a LAN address, and choose the content listener with `--port`:
+
+```bash
+npm run dev -- --app hello-world --public --http --port 8000
+```
+
+The command starts one HTTP listener through `node-http-server`, skips all TLS
+file reads, and serves the same selected source files, generated manifest,
+service worker and offline inventory. PWA configuration and caching are
+unchanged. Startup prints the actual HTTP local and network URLs. Structured
+results contain `protocol:'http:'`; `httpPort`, `httpOrigin`, and `httpUrl`
+identify that content listener and equal `port`, `origin`, and `url`.
+There is no separate redirect endpoint. Cancellation and listener failure
+close the owned HTTP listener and settle the same lifecycle.
+
+`--http` is supported only by `dev`. Combining it with `--https`, `--cert`,
+`--key`, or `--http-port` is a usage error. Omitting it preserves HTTPS;
+certificate errors never select HTTP automatically.
+
+A LAN HTTP origin does not receive the browser's localhost secure-context
+exception. For Chrome development, Chromium documents
+`chrome://flags/#unsafely-treat-insecure-origin-as-secure` with the exact HTTP
+origin, such as `http://192.0.2.10:8000`; see
+[Chromium's development guidance](https://www.chromium.org/Home/chromium-security/deprecating-powerful-features-on-insecure-origins/).
+The developer owns that browser setting. The SDK does not change it, alter
+certificate validation, or claim a PWA is installable merely because its server
+started. HTTP and HTTPS are distinct origins with separate browser storage and
+registrations; existing HTTPS data is preserved.
+
 ### Development HTTPS setup
 
-Before starting `arcane dev` or a packaged browser preview, place the server's
+Before starting HTTPS `arcane dev` or a packaged browser preview, place the server's
 PEM certificate chain at `.arcane/dev/server-cert.pem` and its PEM private key at
 `.arcane/dev/server-key.pem`, relative to the workspace. Alternatively, pass
 `--cert <file> --key <file>` together. The certificate must cover localhost or the LAN IP

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

@@ -6,7 +6,7 @@
     "minimumVersion": "22.23.2 for Node entrypoints",
     "moduleSystem": "ESM"
   },
-  "memberCount": 208,
+  "memberCount": 209,
   "members": [
     {
       "id": "root:APP_BUNDLE_DESCRIPTOR_NAME",
@@ -2902,7 +2902,23 @@
       "summary": "Creates the provider-neutral browser AI API module 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, mutable complete lifecycle status, cancellation, complete all-choice nonstructural stream projection, complete provider data callbacks, single-choice text or multi-choice terminal output, required structural arguments.message, and atomic exact matching nonblank all-ID tool-result sequencing without executing tools; an existing ModelController retains its preconfigured load policy and rejects a new security option"
+      "normalization": "Normalizes lazy or manual load, mutable complete lifecycle status, cancellation, complete all-choice nonstructural stream projection, provider chunks with private structural fields removed, complete terminal data callbacks, optional toolText:{name,field} and distinct onToolText(text,call,displayId) delivery of selected decoded argument text, single-choice text or multi-choice terminal output, required structural arguments.message, and atomic exact matching nonblank all-ID tool-result sequencing without executing tools; an existing ModelController retains its preconfigured load policy and rejects a new security option"
+    },
+    {
+      "id": "tool-text-stream:createToolTextObserver",
+      "name": "createToolTextObserver",
+      "displayName": "createToolTextObserver()",
+      "kind": "function",
+      "signature": "createToolTextObserver(selection, onText, {signal}={})",
+      "entrypoints": [
+        "arcane-os/ai/tool-text-stream"
+      ],
+      "primaryImport": "arcane-os/ai/tool-text-stream",
+      "group": "AI provider integration",
+      "summary": "Observes one selected root string argument from actual tool-call chunks before provider structural filtering.",
+      "availability": "Compatible JavaScript module host; no browser capability required",
+      "protocol": "OpenAI-compatible tool-call deltas and complete message snapshots",
+      "normalization": "Returns null for absent selection or an async chunk observer; preserves decoded text and whitespace, emits actual normalized call identity metadata, observes each raw delta once, avoids replay from complete snapshots, awaits callbacks, and stops later observation after cancellation without altering payloads, executing tools, or persisting history"
     },
     {
       "id": "browser-wasm:createBrowserModelSource",

package/docs/reference/inventory/runtime-modules.json

@@ -10,7 +10,7 @@
   },
   "artifactCount": 85,
   "javascriptArtifactCount": 83,
-  "esmExportCount": 352,
+  "esmExportCount": 353,
   "artifacts": [
     {
       "file": "runtime/arcane/modules/AI.js",
@@ -30,7 +30,7 @@
       "availability": "Browser + native bridge + TWiN Cloud",
       "protocol": "arcane-ai-browser-speech-configuration/1, AIProviderRuntime arcane-ai-provider/2 routes, globalThis.arcaneEvents, TWiN Cloud HTTPS, Arcane.ollama, Arcane.speech, Android WebView bridge",
       "normalization": "Complete mutable caller-owned browser speech authority, SDK-owned provider registration/replacement/disposal, explicit STT/TTS activation, normalized Whisper STT and Kokoro TTS execution with default capacities 1 and 4 respectively, explicit provider-neutral execution snapshots through status(role,{execution:true}), sticky readiness, canonical window.user readiness without compatibility-event object-identity admission or polling, exact ordered structural calls with required arguments.message, atomic nonblank all-ID tool-result sequencing, complete all-choice streaming/data validation, native Ollama structural adaptation, complete-response then all validated tool callbacks then completion ordering, observed async callbacks, Blob/File transcription, automatic repeated-formatting-mark removal from cloned outbound TTS input while caller and visible content stays exact, immediate exact-segment synthesis, per-call voice/speed capture, optional final-segment pause on the existing audio clock, optional per-call terminal playback completion, detached preparation with complete semantic DBOPFS audio reuse and same-owner pending request sharing, independent prepared playback without a model load for cached audio, ordered audio-clock scheduling, playable audio, active-generation TTS operation-failure routing, mute, and cancellation are normalized; provider/model/runtime/voice policy remains caller-owned. Both speech roles default execution.device to auto: webnn-npu when navigator.ml.createContext is exposed, then webgpu when navigator.gpu is exposed, then wasm for CPU execution. Failed backend loads clean up the pool before trying fresh Workers with the same prepared model and dtype; explicit devices never fall back. STT capacity only accepts 1; TTS accepts 1 through 4. Execution snapshots expose requestedDevice, selectedDevice, maxConcurrentRequests, and activeRequestCount for both roles; selectedDevice is null while unloaded and names the successful upstream session backend request when loaded. It does not prove every operation used the physical NPU: WebNN unsupported operations may use WASM, and compatibility depends on the browser, driver, hardware, and graph.",
-      "surface": "Browser-speech protocol/event/error/reason constants; default `AI`; read-only `providerRuntime`, `browserSpeechConfiguration`, and `browserSpeechDescriptor`; explicit `providerRuntime.status(role,{execution:true})` snapshots; `streamTTS(text,end,options={})` with optional voice, speed, pauseAfterMs, and waitForPlayback; automatic speech-input cleanup with SDK-internal preparation metadata; `prepareTTS({parts,storage,identity,signal,onState})` returning ordered segments, state, ready, getAudio(index), and cancel(); `playPreparedTTS(prepared,{signal,onState})` returning state, error, finished, pause(), resume(), and stop() with one playback lane per AI and observational state/error callbacks; configure/dispose speech, route lifecycle, declaration-validated chat/stream requests with exact ordered calls, synthesis/transcription, and playback controls; initializes from current canonical user readiness, installs `window.ai`, and projects `ai-ready` plus active-generation `ai-tts-failure`."
+      "surface": "Browser-speech protocol/event/error/reason constants; default `AI`; read-only `providerRuntime`, `browserSpeechConfiguration`, and `browserSpeechDescriptor`; explicit `providerRuntime.status(role,{execution:true})` snapshots; `streamTTS(text,end,options={})` with optional voice, speed, pauseAfterMs, and waitForPlayback; automatic speech-input cleanup with SDK-internal preparation metadata; `prepareTTS({parts,storage,identity,signal,onState})` returning ordered segments, state, ready, getAudio(index), and cancel(); `playPreparedTTS(prepared,{signal,onState})` returning state, error, finished, pause(), resume(), and stop() with one playback lane per AI and observational state/error callbacks; configure/dispose speech, route lifecycle, declaration-validated chat/stream requests with exact ordered calls; optional streamRequest toolText:{name,field} and onToolText(text,call,displayId) for decoded selected argument text with actual call identity, distinct from ordinary prose and terminal tool execution; synthesis/transcription and playback controls; initializes from current canonical user readiness, installs `window.ai`, and projects `ai-ready` plus active-generation `ai-tts-failure`."
     },
     {
       "file": "runtime/arcane/modules/AIPreferenceRuntime.js",
@@ -456,13 +456,14 @@
         "conversationClosingReportInstruction",
         "createConversationClosingReportTool",
         "formatConversationClosingReport",
+        "formatConversationClosingReportText",
         "normalizeConversationClosingReport"
       ],
       "summary": "Defines the closing-report tool, instruction, result normalizer, call classifier, and formatter.",
       "availability": "Cross-host",
       "protocol": "In-process only",
       "normalization": "Required user-facing message remains distinct from the complete final_message; normalized results expose message, finalMessage, and rememberedActions.",
-      "surface": "Six constants/helpers for closing reports; the sole-call schema requires message and final_message."
+      "surface": "Seven constants/helpers for closing reports; the sole-call schema requires message and final_message. formatConversationClosingReportText(value) exposes the existing &, <, and > escaping for any string, including whitespace-only chunks, and the complete report formatter reuses it."
     },
     {
       "file": "runtime/arcane/modules/ConversationTimebox.js",

package/docs/reference/pwa.md

@@ -112,9 +112,11 @@ For an enabled application, `arcane dev` serves the generated PWA files at the
 origin root and starts at the selected app page under `/apps/<id>/`. Use one
 selected app per development origin. The SDK uses `node-http-server` for source
 and packaged-preview serving, including conditional resource responses.
-Every Arcane development server and packaged browser preview serves HTTPS,
-including localhost. Configure the workspace certificate pair before starting
-the ordinary command; see [development HTTPS setup](cli.md#development-https-setup).
+Arcane development servers default to HTTPS, including localhost, and packaged
+browser previews require HTTPS. Configure the workspace certificate pair before
+starting the ordinary command; see [development HTTPS setup](cli.md#development-https-setup).
+Explicit source-only `arcane dev --http` serves the same generated PWA routes
+without loading certificates; see [explicit HTTP development](cli.md#explicit-http-development).
 `--public` selects the IPv4 wildcard bind address; it does not enable PWA
 configuration, change manifest metadata, or determine browser installability.
 
@@ -272,8 +274,11 @@ Keep actual icon dimensions in `sizes`. Browser diagnostics about missing
 and are separate from a usable installation icon.
 
 Browser installation requires HTTPS or the browser's localhost/loopback
-exception. A device-facing LAN address is not loopback. Arcane's development
-server still follows its own HTTPS serving contract above. Browser engagement,
+exception. A device-facing LAN address is not loopback. Selecting HTTP serving
+does not make that LAN origin a secure context. Chromium documents a separate
+[explicit developer origin setting](https://www.chromium.org/Home/chromium-security/deprecating-powerful-features-on-insecure-origins/);
+the SDK does not configure that setting or claim that starting the server proves
+installation eligibility. Browser engagement,
 installation state and platform support also affect whether native promotion
 appears; worker cache readiness is not an installation UI prerequisite. See
 [browser installation requirements](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable).