Release 0.1.63 [auto-version-bump]

README.md

@@ -10,7 +10,7 @@ If the player asks to find or approach someone and no NPC is present, the direct
 
 The separate `/admin` route provides an authenticated operations view for player search/profile/trace, YAML prompt assets, generated Luau rules with validation results, runtime debug logging, and the append-only audit log. All privileged data comes from the Rust `/api/admin/...` API; the browser never connects directly to PostgreSQL. Backend endpoints require `accounts.is_admin=true`. The Driftloggar view lets an administrator switch `debug=true` on or off without restarting pods; the setting is stored in PostgreSQL and propagated to running replicas. Verbose pod logs include request, AI-call, validation, and commit metadata but never raw player text, prompts, model responses, sessions, or secrets. Full protected prompt/provider exchanges remain in the audited player trace.
 
-The game is text- and dialogue-based and uses no images. Place descriptions include sound, smell, air/temperature, touch/surface, and spatial-orientation cues. Visible details may also be described in words, but are never required to understand the scene or play. The transcript is screen-reader announced, and Enter submits the input while Shift+Enter inserts a newline; no separate send button is required.
+The game is text- and dialogue-based and uses no images. Place descriptions include sound, smell, air/temperature, touch/surface, and spatial-orientation cues. Visible details may also be described in words, but are never required to understand the scene or play. The transcript is screen-reader announced. A clearly labeled **Skicka** button beside the microphone submits typed text; Enter also submits while Shift+Enter inserts a newline. Typed text, speech transcriptions, and the send button all use the same submission flow.
 
 Player-facing speech uses Piper TTS in WebAssembly in the browser after audio is activated by a user gesture. It reads game dialogue, onboarding, account responses, character and world creation, gameplay replies, in-game errors, and microphone disclosures; the `/admin` route is excluded. The audio is decoded and played through the Web Audio API, independently of `speechSynthesis`. The first unauthenticated visit keeps the introduction visible and it can be started with `Läs introduktionen`. New game replies are read automatically and the transcript remains available to screen readers and as text. Returning players hear the latest saved game reply when they reopen the game. The player can change speaking rate; narrator pitch is neutral and character pitch is varied consistently by voice identity. These preferences are stored in browser `localStorage`. If WebAssembly, model loading, or audio playback fails, the same content remains available as text and the dialogue offers a retry.
 

VERSION

@@ -1 +1 @@
-0.1.51
+0.1.63

deploy/helm/ai-spel-frontend/Chart.yaml

@@ -2,5 +2,5 @@ apiVersion: v2
 name: ai-spel-frontend
 description: Static web frontend for the Swedish life simulator
 type: application
-version: 0.1.51
+version: 0.1.63
-appVersion: "0.1.51"
+appVersion: "0.1.63"

docs/adr/0001-piper-es-module-worker.md

@@ -0,0 +1,13 @@
+# ADR 0001: Run Piper in an ES module worker
+
+## Decision
+
+Bundle the Piper worker as an ES module and start it with `new Worker(url, { type: 'module' })`.
+
+## Context
+
+Piper loads ONNX Runtime Web and its WebAssembly loader dynamically. The current IIFE/classic worker bundle reports `TypeError: "undefined" cannot be parsed as a URL` during WASM backend initialization, even though the pinned same-origin ONNX loader and binary are available. This is consistent with module-relative URL metadata being lost in the classic bundle.
+
+## Consequences
+
+The browser must support module workers. Current supported browser targets already require modern WebAssembly and worker support. CI asserts that the worker is built and started in module mode; production acceptance remains the real deployed browser flow.

docs/adr/0002-single-thread-onnx-for-mobile-tts.md

@@ -0,0 +1,13 @@
+# ADR 0002: Run ONNX with one thread inside the Piper worker
+
+## Decision
+
+Configure ONNX Runtime Web to use one thread and stop backend initialization after 60 seconds. Piper already runs in a dedicated worker, so ONNX does not need to create another worker pool.
+
+## Context
+
+On iPad, the threaded ONNX WASM file downloaded fully, but the runtime did not report that initialization had completed. Nested worker startup and shared-memory setup are a likely compatibility boundary on mobile Safari. The available production assets currently include the threaded ONNX build.
+
+## Consequences
+
+This removes ONNX's additional worker pool and bounds initialization failures with a visible error. It may reduce inference throughput on desktop devices. CI and Kubernetes release verification must confirm that Piper still initializes and speaks on supported browsers; iPad acceptance remains a manual device check.

docs/adr/0003-limit-piper-wasm-to-one-thread.md

@@ -0,0 +1,13 @@
+# ADR 0003: Limit Piper WASM to one thread and reset failed workers
+
+## Decision
+
+The Piper worker reports one available processor to Piper and configures ONNX Runtime for one thread. If a synthesis request fails, the browser client terminates that worker; the next player retry creates a fresh worker and ONNX module.
+
+## Context
+
+Piper TTS Web 1.0.3 sets `env.wasm.numThreads` from `navigator.hardwareConcurrency` during `TtsSession.init()`, after the application had configured ONNX Runtime. On iPad this could undo the single-thread setting and request a larger WASM worker pool. The library also retains a singleton session if ONNX initialization fails, so retrying in the same worker can reuse a failed initialization.
+
+## Consequences
+
+The one-thread limit reduces parallel inference but lowers memory pressure on mobile Safari. Failed initialization no longer poisons future attempts in the same worker. This cannot guarantee that every device has enough memory for the 63 MB medium voice model; the CI release and Kubernetes checks validate packaging and deployment, while actual iPad memory behavior still requires device verification.

index.html

@@ -20,6 +20,8 @@
     #message { width: 100%; min-height: 3.5rem; box-sizing: border-box; }
     #message-tools { display: flex; flex-wrap: wrap; align-items: center; gap: .5rem; }
     #voice-status { min-height: 1.5em; }
+    #speech-progress { width: min(100%, 32rem); height: 1.25rem; }
+    #speech-progress-value { margin-inline-start: .5rem; font-variant-numeric: tabular-nums; }
     #dialogue li[data-role="voice-controls"] { border: 1px solid currentColor; border-radius: .35rem; padding: .75rem; }
     #dialogue li[data-role="voice-controls"] fieldset { display: grid; gap: .5rem; margin-block: .5rem; }
     #admin-content { display: grid; gap: 1rem; }
@@ -27,6 +29,31 @@
     #admin-content pre { white-space: pre-wrap; overflow-wrap: anywhere; max-height: 32rem; overflow: auto; }
     #admin-toolbar { display: flex; flex-wrap: wrap; gap: .5rem; margin-block: 1rem; }
     #player-search { display: flex; flex-wrap: wrap; align-items: end; gap: .5rem; }
+    body.debug-layout { max-width: none; margin: 0; padding: .5rem; height: 100vh; overflow: hidden; }
+    #play-layout.debug-enabled { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); gap: .75rem; height: calc(100vh - 4rem); }
+    #play-layout.debug-enabled #play, #play-layout.debug-enabled #debug-panel { min-width: 0; height: 100%; overflow: auto; padding: 1rem; box-sizing: border-box; }
+    #play-layout.debug-enabled #debug-panel { border-inline-start: 1px solid currentColor; }
+    #debug-panel h2 { margin-block-start: 0; }
+    #debug-trace { display: grid; gap: .6rem; }
+    #debug-trace details { border: 1px solid currentColor; border-radius: .3rem; padding: .5rem; }
+    #debug-trace summary { cursor: pointer; overflow-wrap: anywhere; }
+    #debug-trace pre { white-space: pre-wrap; overflow-wrap: anywhere; font: .8rem/1.45 ui-monospace, monospace; }
+    .trace-chain { display: grid; gap: .65rem; margin-block: .75rem; }
+    .trace-step { border: 1px solid currentColor; border-inline-start: .35rem solid currentColor; border-radius: .3rem; padding: .65rem; }
+    .trace-step[data-engine="player"] { border-inline-start-color: #64748b; }
+    .trace-step[data-engine="ai"] { border-inline-start-color: #2563eb; }
+    .trace-step[data-engine="luau"] { border-inline-start-color: #9333ea; }
+    .trace-step[data-engine="rust"] { border-inline-start-color: #c2410c; }
+    .trace-step h3 { font-size: 1rem; margin: 0 0 .5rem; }
+    .trace-step .trace-engine { font-weight: 750; }
+    .trace-step pre { margin: .25rem 0 .75rem; }
+    .trace-raw { margin-block-start: .75rem; }
+    @media (max-width: 800px) {
+      body.debug-layout { height: auto; overflow: auto; }
+      #play-layout.debug-enabled { grid-template-columns: minmax(0, 1fr); height: auto; }
+      #play-layout.debug-enabled #play { min-height: 55vh; }
+      #play-layout.debug-enabled #debug-panel { min-height: 45vh; border-inline-start: 0; border-block-start: 1px solid currentColor; }
+    }
     .sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; border: 0; }
     [hidden] { display: none !important; }
     footer { margin-top: 2rem; border-top: 1px solid; padding-top: .5rem; color: GrayText; font-size: .875rem; }
@@ -46,17 +73,31 @@
         <div><button type="submit" name="intent" value="login">Logga in</button> <button type="submit" name="intent" value="register">Skapa konto</button></div>
       </form>
     </section>
+    <div id="play-layout">
     <section id="play" aria-label="Spelets dialog" hidden>
       <h1 class="sr-only">Dialog</h1>
       <ol id="dialogue" aria-label="Dialoghistorik" role="log" aria-live="polite" aria-relevant="additions text"></ol>
       <form id="message-form">
         <label for="message" id="message-label">Skriv ett meddelande</label>
         <textarea id="message" name="message" maxlength="4000" aria-describedby="message-help" autocomplete="off"></textarea>
-        <div id="message-tools"><button type="button" id="microphone" aria-pressed="false" aria-describedby="voice-status">Starta mikrofon</button></div>
+        <div id="message-tools"><button type="submit" id="send-message">Skicka</button> <button type="button" id="microphone" aria-pressed="false" aria-describedby="voice-status">Starta mikrofon</button></div>
-        <span id="message-help" class="sr-only">Tryck Enter för att skicka. Tryck Skift och Enter för ny rad.</span>
+        <span id="message-help" class="sr-only">Tryck på Skicka eller Enter för att skicka. Tryck Skift och Enter för ny rad.</span>
       </form>
       <p id="voice-status" role="status" aria-live="polite"></p>
+      <div id="speech-progress-container" hidden>
+        <label for="speech-progress">Hämtar svensk röstmodell till enheten</label>
+        <progress id="speech-progress" aria-label="Nedladdning av svensk röstmodell"></progress>
+        <output id="speech-progress-value" for="speech-progress">Väntar på nedladdning</output>
+      </div>
     </section>
+    <aside id="debug-panel" aria-labelledby="debug-heading" hidden>
+      <h2 id="debug-heading">Beslutsspårning</h2>
+      <p>Administratörsvy för ditt eget spelkonto. Varje steg visar sparad indata och utdata i kedjan: spelare (grå), AI (blå), Luau (lila) och Rust (orange). Promptar, modelltrafik, regelresultat och commit visas från revisionsloggad API-data. Hemligheter och credentials maskeras av servern.</p>
+      <button type="button" id="debug-refresh">Uppdatera spår</button>
+      <p id="debug-status" role="status" aria-live="polite">Hämtar spårning…</p>
+      <div id="debug-trace" aria-label="Kronologiskt beslutsspår"></div>
+    </aside>
+    </div>
     <section id="admin-view" aria-labelledby="admin-heading" hidden>
       <h1 id="admin-heading">Administration</h1>
       <p>Privilegierad läsning loggas. Känsligt spelarinnehåll visas bara här för administratörer.</p>
@@ -77,6 +118,10 @@
   <script>
     const auth = document.querySelector('#auth');
     const play = document.querySelector('#play');
+    const playLayout = document.querySelector('#play-layout');
+    const debugPanel = document.querySelector('#debug-panel');
+    const debugTrace = document.querySelector('#debug-trace');
+    const debugStatus = document.querySelector('#debug-status');
     const adminView = document.querySelector('#admin-view');
     const adminContent = document.querySelector('#admin-content');
     const transcript = document.querySelector('#dialogue');
@@ -86,6 +131,8 @@
     let characterDraft = null;
     let worldDraft = null;
     let gameState = null;
+    let currentAccount = null;
+    let debugRefreshBusy = false;
     let submitBusy = false;
     let pendingDialogue = null;
     let latestAssistantText = '';
@@ -157,6 +204,62 @@
       const authVoiceStatus = document.querySelector('#auth-voice-status');
       if (authVoiceStatus && !auth.hidden && message) authVoiceStatus.textContent = message;
     }
+    function updateSpeechProgress(message = '') {
+      const container = document.querySelector('#speech-progress-container');
+      const progress = document.querySelector('#speech-progress');
+      const value = document.querySelector('#speech-progress-value');
+      const label = container.querySelector('label');
+      const preparing = message.startsWith('Förbereder svensk uppläsning.');
+      const phase = [
+        'Laddar WebAssembly-motorn för svensk uppläsning.',
+        'Startar WebAssembly-motorn efter nedladdning av',
+        'Hämtar information om den svenska röstmodellen.',
+        'Ansluter till servern för att hämta den svenska röstmodellen.',
+        'Läser in den svenska röstmodellen.',
+        'Röstmodellen är inläst. Skapar uppläsningen.',
+      ].find(text => message.startsWith(text));
+      const match = message.match(/^Hämtar svensk röstmodell till enheten: (\d+) procent\.$/);
+      const bytesMatch = message.match(/^Hämtar svensk röstmodell till enheten: ([\d.,]+) MB hämtade\.$/);
+      const runtimeFile = message.match(/^(?:Hämtar|Läser in) WebAssembly-filen ([\w.-]+)\.?$/);
+      const runtimePercent = message.match(/^Hämtar WebAssembly-filen ([\w.-]+): (\d+) procent\.$/);
+      const runtimeBytes = message.match(/^Hämtar WebAssembly-filen ([\w.-]+): ([\d.,]+) MB hämtade\.$/);
+      if (!preparing && !phase && !match && !bytesMatch && !runtimeFile && !runtimePercent && !runtimeBytes) {
+        container.hidden = true;
+        progress.removeAttribute('value');
+        value.textContent = 'Väntar på nedladdning';
+        return false;
+      }
+      container.hidden = false;
+      label.textContent = runtimePercent || runtimeBytes
+        ? `Hämtar WebAssembly-filen ${runtimePercent?.[1] || runtimeBytes?.[1]}`
+        : runtimeFile
+          ? runtimeFile[0].replace(/\.$/, '')
+          : phase || 'Hämtar svensk röstmodell till enheten';
+      if (runtimePercent) {
+        progress.value = Math.max(0, Math.min(100, Number(runtimePercent[2])));
+        value.textContent = `${runtimePercent[2]}%`;
+        return true;
+      }
+      if (runtimeBytes) {
+        progress.removeAttribute('value');
+        value.textContent = `${runtimeBytes[2]} MB hämtade`;
+        return true;
+      }
+      if (match) {
+        const percent = Math.max(0, Math.min(100, Number(match[1])));
+        progress.value = percent;
+        value.textContent = `${percent}%`;
+        return true;
+      }
+      if (bytesMatch) {
+        progress.removeAttribute('value');
+        value.textContent = `${bytesMatch[1]} MB hämtade`;
+        return true;
+      }
+      progress.removeAttribute('value');
+      value.textContent = phase ? 'Pågår…' : 'Förbereder…';
+      return true;
+    }
     function clearSpeechRecovery() {
       speechRecoveryElement?.remove();
       speechRecoveryElement = null;
@@ -187,6 +290,8 @@
     function refreshMicrophone() {
       const button = document.querySelector('#microphone');
       if (button) button.disabled = play.hidden || messageField.disabled || submitBusy;
+      const sendButton = document.querySelector('#send-message');
+      if (sendButton) sendButton.disabled = play.hidden || messageField.disabled || submitBusy;
     }
     function persistVoiceSettings() {
       voiceSettings.mode = 'game-voice';
@@ -218,8 +323,15 @@
         microphone.setAttribute('aria-pressed', String(listening));
         microphone.textContent = listening ? 'Avsluta mikrofon' : 'Starta mikrofon';
         refreshMicrophone();
-        if (message) setVoiceStatus(message);
+        if (message) {
-        else if (state === 'IDLE') setVoiceStatus('');
+          const downloading = updateSpeechProgress(message);
+          setVoiceStatus(downloading && message.startsWith('Hämtar svensk röstmodell')
+            ? 'Hämtar svensk röstmodell till enheten.'
+            : message);
+        } else if (state === 'IDLE') {
+          updateSpeechProgress('');
+          setVoiceStatus('');
+        }
         if (/Läs senaste repliken/.test(message)) showSpeechRecovery(message);
         playVoiceSignal(state === 'IDLE' && /Mikrofonen är avstängd/.test(message) ? 'STOPPED' : state);
       },
@@ -342,6 +454,9 @@
     function showAuth() {
       stage = 'auth';
       play.hidden = true;
+      debugPanel.hidden = true;
+      playLayout.classList.remove('debug-enabled');
+      document.body.classList.remove('debug-layout');
       adminView.hidden = true;
       auth.hidden = false;
       document.querySelector('#auth-heading').textContent = location.pathname === '/admin' ? 'Administratörsinloggning' : 'Svensk livssimulator';
@@ -356,6 +471,10 @@
       auth.hidden = true;
       adminView.hidden = true;
       play.hidden = false;
+      const showDebug = currentAccount?.is_admin === true;
+      debugPanel.hidden = !showDebug;
+      playLayout.classList.toggle('debug-enabled', showDebug);
+      document.body.classList.toggle('debug-layout', showDebug);
       refreshMicrophone();
       messageField.focus();
     }
@@ -365,6 +484,9 @@
       voiceController.stopAll();
       auth.hidden = true;
       play.hidden = true;
+      debugPanel.hidden = true;
+      playLayout.classList.remove('debug-enabled');
+      document.body.classList.remove('debug-layout');
       adminView.hidden = false;
       document.querySelector('#version-footer').hidden = true;
     }
@@ -528,8 +650,7 @@
           body: JSON.stringify({input: message, current_draft: worldDraft}),
         });
         worldDraft = proposal.draft;
-        const senses = worldDraft.location_senses;
+        appendLine('assistant', `${proposal.message}\n\nVärld: ${worldDraft.name}\nStartplats: ${worldDraft.location_name}. ${worldDraft.location_description}\nStartbelopp: ${worldDraft.starting_balance_sek} kronor. ${worldDraft.offer_name} kostar ${worldDraft.offer_price_sek} kronor.\n\nSkriv ändringar eller “godkänn”.`);
-        appendLine('assistant', `${proposal.message}\n\nVärld: ${worldDraft.name}\nStartplats: ${worldDraft.location_name}. ${worldDraft.location_description}\nLjud: ${senses.sound}\nDoft: ${senses.smell}\nLuft och temperatur: ${senses.air_and_temperature}\nBeröring och ytor: ${senses.touch_and_surfaces}\nOrientering: ${senses.spatial_orientation}\nStartbelopp: ${worldDraft.starting_balance_sek} kronor. ${worldDraft.offer_name} kostar ${worldDraft.offer_price_sek} kronor.\n\nSkriv ändringar eller “godkänn”.`);
       } catch (error) {
         appendLine('assistant', `Förslaget kunde inte tas fram: ${error.message}. Skriv “försök igen” när du vill försöka på nytt.`);
       }
@@ -562,21 +683,22 @@
       const lines = await request('/api/dialogue');
       transcript.replaceChildren();
       latestAssistantText = '';
-      for (const line of lines) appendLine(line.role === 'user' ? 'user' : 'assistant', line.content, {speak: false});
+      for (const line of lines) appendLine(line.role === 'user' ? 'user' : 'assistant', line.content, {speaker: line.speaker, speak: false});
       if (lines.length > 0 && latestAssistantText && location.pathname !== '/admin') {
         voiceController?.speak(latestAssistantText, {role: 'narrator', voiceIdentity: 'neutral'});
       } else if (lines.length === 0 && gameState?.world) {
         const place = gameState.world.location;
-        const senses = place.senses || {};
+        appendLine('assistant', `Du börjar på ${place.name}. ${place.description}`);
-        appendLine('assistant', `Du börjar på ${place.name}. ${place.description} Ljud: ${senses.sound || 'Inget särskilt ljud beskrivet.'} Doft: ${senses.smell || 'Ingen särskild doft beskriven.'} Luft och temperatur: ${senses.air_and_temperature || 'Inte beskrivet.'} Beröring och ytor: ${senses.touch_and_surfaces || 'Inte beskrivet.'} Orientering: ${senses.spatial_orientation || 'Inte beskrivet.'}`);
       }
     }
     async function openGame() {
+      currentAccount = await request('/api/me');
       gameState = await request('/api/world');
       showPlay();
       if (!gameState.character) {
         transcript.replaceChildren();
         appendInitialPrompt();
+        if (currentAccount.is_admin) await refreshDecisionTrace();
         return;
       }
       characterDraft = null;
@@ -584,13 +706,145 @@
         worldDraft = null;
         appendLine('assistant', 'Nu föreslår jag en startplats som passar biografin. Du kan ändra förslaget innan något sparas. Skriv “börja”.');
         setStage('world-draft');
+        if (currentAccount.is_admin) await refreshDecisionTrace();
         return;
       }
       await loadSavedDialogue();
+      if (currentAccount.is_admin) await refreshDecisionTrace();
       setStage('game');
       startPlayerPresence();
       announcePlayerChatHelp();
     }
+
+    function traceTimestamp(record) {
+      return record.recorded_at || record.requested_at || record.completed_at || record.created_at || '';
+    }
+    function renderDecisionTrace(data) {
+      const groups = new Map();
+      for (const [kind, records] of Object.entries({events: data.events || [], ai_interactions: data.ai_interactions || [], player_messages: data.player_messages || []})) {
+        for (const record of records) {
+          const key = record.correlation_id || `${kind}:${record.event_id || record.id || traceTimestamp(record)}`;
+          if (!groups.has(key)) groups.set(key, {correlation_id: key, events: [], ai_interactions: [], player_messages: [], latest: ''});
+          const group = groups.get(key);
+          group[kind].push(record);
+          const time = traceTimestamp(record);
+          if (time > group.latest) group.latest = time;
+        }
+      }
+      const ordered = [...groups.values()].sort((a, b) => b.latest.localeCompare(a.latest));
+      debugTrace.replaceChildren();
+      if (ordered.length === 0) {
+        const empty = document.createElement('p');
+        empty.textContent = 'Ingen sparad spårning för kontot ännu.';
+        debugTrace.append(empty);
+        return;
+      }
+      for (const group of ordered) {
+        const details = document.createElement('details');
+        details.open = debugTrace.childElementCount === 0;
+        const summary = document.createElement('summary');
+        const eventNames = group.events.map(event => `${event.event_type} (${event.commit_status || 'okänt utfall'})`).join(', ');
+        const prompts = group.ai_interactions.map(interaction => `${interaction.prompt_id} v${interaction.prompt_version}: ${interaction.outcome}`).join(', ');
+        summary.textContent = `${group.latest || 'Tid saknas'} · ${group.correlation_id}${eventNames ? ` · Rust: ${eventNames}` : ''}${prompts ? ` · AI: ${prompts}` : ''}`;
+        const chain = document.createElement('div');
+        chain.className = 'trace-chain';
+        const addStep = (engine, title, input, output, note = '') => {
+          const card = document.createElement('article');
+          card.className = 'trace-step';
+          card.dataset.engine = engine;
+          const heading = document.createElement('h3');
+          const label = document.createElement('span');
+          label.className = 'trace-engine';
+          label.textContent = `${engine === 'luau' ? 'Luau' : engine === 'ai' ? 'AI' : engine === 'rust' ? 'Rust' : 'Spelare'} · `;
+          heading.append(label, document.createTextNode(title));
+          card.append(heading);
+          if (note) {
+            const noteElement = document.createElement('p');
+            noteElement.textContent = note;
+            card.append(noteElement);
+          }
+          const addValue = (name, value) => {
+            const valueHeading = document.createElement('strong');
+            valueHeading.textContent = name;
+            const pre = document.createElement('pre');
+            pre.textContent = typeof value === 'string' ? value : JSON.stringify(value ?? 'Ingen uppgift sparad', null, 2);
+            card.append(valueHeading, pre);
+          };
+          addValue('Indata', input);
+          addValue('Utdata', output);
+          chain.append(card);
+        };
+
+        const orderedEvents = [...group.events].sort((a, b) => traceTimestamp(a).localeCompare(traceTimestamp(b)));
+        const orderedInteractions = [...group.ai_interactions].sort((a, b) => traceTimestamp(a).localeCompare(traceTimestamp(b)));
+        const playerMessages = [
+          ...orderedEvents.map(event => event.payload?.player_message).filter(Boolean),
+          ...group.player_messages.map(message => message.message).filter(Boolean),
+        ];
+        for (const [index, message] of playerMessages.entries()) {
+          addStep('player', `Spelarens avsikt ${playerMessages.length > 1 ? index + 1 : ''}`, message, {submitted: true});
+        }
+
+        for (const interaction of orderedInteractions) {
+          const external = interaction.external_call || {};
+          addStep('ai', `${interaction.prompt_id} · v${interaction.prompt_version} · ${interaction.outcome}`,
+            {prompt_yaml: interaction.prompt_yaml, rendered_messages: interaction.rendered_messages, provider: external.service, model: external.model, thinking_effort: external.thinking_effort, provider_request: external.request},
+            {response: interaction.response, outcome: interaction.outcome, provider_status: external.response_status, provider_response: external.response_body, provider_error: external.error, duration_ms: external.duration_ms, rust_interpretation_and_validation: interaction.metadata},
+            'AI-förslag och providertrafik. Förslaget är inte i sig ett fastställt världsfaktum.');
+          const metadata = interaction.metadata || {};
+          if (metadata.validation_inputs || metadata.validation_results || metadata.decision?.includes?.('rule')) {
+            addStep('luau', `Regelutkast och tester · ${metadata.rule_key || metadata.activity_key || interaction.prompt_id}`,
+              {rule_draft: interaction.response, test_inputs: metadata.validation_inputs},
+              {decision: metadata.decision || interaction.outcome, test_results: metadata.validation_results, source_hash: metadata.source_hash, rule_id: metadata.rule_id, rule_version: metadata.rule_version},
+              'Luau körs med isolerade testindata; resultatet kontrolleras av Rust innan regeln aktiveras.');
+          }
+        }
+
+        for (const event of orderedEvents) {
+          const payload = event.payload || {};
+          const domain = payload.details || {};
+          const luau = domain.luau_trace;
+          if (luau) {
+            addStep('luau', `Regelkörning · ${domain.activity_key || domain.rule_id || 'regel'}`,
+              {source: event.rule_source || 'Källkod saknas i denna spårpost.', invocation: luau.input},
+              luau.error ? {error: luau.error, output: luau.output} : luau.output,
+              `Regel ${domain.rule_id || 'okänd'} version ${domain.rule_version ?? 'okänd'} · hash ${domain.rule_hash || 'saknas'}`);
+            addStep('rust', 'Effektvalidering och världskommando',
+              {proposed_effects: domain.rust_validation?.input_effects || luau.output, activity: domain.activity_key, world_version_before: luau.input?.snapshot?.version},
+              {validation: domain.rust_validation, committed_event: event.event_type, commit_status: event.commit_status, commit_sequence: event.commit_sequence, world_time: event.world_time, committed_details: domain},
+              'Rust verifierar typade effekter och skriver den godkända förändringen atomärt.');
+          } else {
+            addStep('rust', `Domänbeslut och commit · ${event.event_type}`,
+              {player_intent: payload.player_message, interpreted_intent: payload.intent, details: domain, world_version: payload.world_version},
+              {commit_status: event.commit_status, commit_sequence: event.commit_sequence, world_time: event.world_time, event_id: event.event_id},
+              'Rust fastställer om handlingen kan committas till den kanoniska världen.');
+          }
+        }
+        const raw = document.createElement('details');
+        raw.className = 'trace-raw';
+        const rawSummary = document.createElement('summary');
+        rawSummary.textContent = 'Visa all rå spårdata';
+        const pre = document.createElement('pre');
+        pre.textContent = JSON.stringify(group, null, 2);
+        raw.append(rawSummary, pre);
+        details.append(summary, chain, raw);
+        debugTrace.append(details);
+      }
+    }
+    async function refreshDecisionTrace() {
+      if (!currentAccount?.is_admin || debugRefreshBusy || debugPanel.hidden) return;
+      debugRefreshBusy = true;
+      debugStatus.textContent = 'Hämtar revisionsloggad spårning…';
+      try {
+        const trace = await request('/api/admin/self/trace?limit=200');
+        renderDecisionTrace(trace);
+        debugStatus.textContent = `Visar ${debugTrace.childElementCount} korrelerade händelsegrupper. Uppdaterad ${new Date().toLocaleTimeString('sv-SE')}.`;
+      } catch (error) {
+        debugStatus.textContent = `Spårningen kunde inte hämtas: ${error.message}`;
+      } finally {
+        debugRefreshBusy = false;
+      }
+    }
     function announcePlayerChatHelp() {
       const key = 'ai-spel.player-chat-help.v1';
       try {
@@ -703,9 +957,12 @@
           } catch (_) { /* The committed dialogue stays successful if this optional view refresh fails. */ }
         }
         const speakingNpc = ['speak', 'meet'].includes(result.intent) ? gameState.world.npc : null;
+        for (const ruleName of result.debug_rules_created || []) {
+          appendLine('assistant', ruleName, {speaker: 'Nya regler', speak: false});
+        }
         appendLine('assistant', result.reply, speakingNpc
           ? {speaker: speakingNpc.name, voice: {characterId: speakingNpc.id, voiceIdentity: speakingNpc.voice_identity}}
-          : {speaker: 'Berättelsen', voice: {role: 'narrator', voiceIdentity: 'neutral'}});
+          : {speaker: 'Berättaren', voice: {role: 'narrator', voiceIdentity: 'neutral'}});
       } catch (error) {
         messageField.value = message;
         appendLine('assistant', `${explainDialogueError(error)} Ditt meddelande ligger kvar i inmatningen.`);
@@ -752,6 +1009,7 @@
       } finally {
         submitBusy = false;
         refreshMicrophone();
+        if (currentAccount?.is_admin) await refreshDecisionTrace();
         if (!play.hidden && !messageField.disabled) messageField.focus();
       }
     }
@@ -852,6 +1110,7 @@
       finally { adminContent.setAttribute('aria-busy', 'false'); }
     }));
     document.querySelector('#admin-logout').addEventListener('click', handleLogout);
+    document.querySelector('#debug-refresh').addEventListener('click', refreshDecisionTrace);
     messageField.addEventListener('keydown', (event) => {
       if (event.key === 'Enter' && !event.shiftKey && !event.isComposing) {
         event.preventDefault();

piper-download-progress.mjs

@@ -0,0 +1,37 @@
+export function trackDownloadProgress(response, {id, postMessage, asset = 'model', file}) {
+  const reader = response.body?.getReader?.();
+  if (!reader || typeof ReadableStream !== 'function' || typeof Response !== 'function') return response;
+
+  const total = Number(response.headers.get('content-length')) || 0;
+  let loaded = 0;
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const {done, value} = await reader.read();
+        if (done) {
+          if (asset === 'runtime') {
+            postMessage({id, type: 'progress', progress: {stage: 'initializing-runtime', file}});
+          }
+          controller.close();
+          return;
+        }
+        loaded += value.byteLength;
+        const progress = {asset, loaded, total};
+        if (file) progress.file = file;
+        postMessage({id, type: 'progress', progress});
+        controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    },
+  });
+
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}

piper-onnx-config.mjs

@@ -5,3 +5,27 @@ export function createOnnxWasmPaths(origin) {
   return absoluteAssetRoot;
 }
 
+export function configureOnnxRuntime(onnxRuntime) {
+  if (!onnxRuntime?.env?.wasm) throw new TypeError('ONNX Runtime WebAssembly settings are unavailable.');
+  // Piper 1.0.3 overwrites this value in TtsSession.init() with
+  // navigator.hardwareConcurrency. Override that source as well, otherwise an
+  // iPad may start a large WASM worker pool despite this setting.
+  const navigatorObject = globalThis.navigator;
+  if (navigatorObject && navigatorObject.hardwareConcurrency !== 1) {
+    try {
+      Object.defineProperty(navigatorObject, 'hardwareConcurrency', {
+        configurable: true,
+        value: 1,
+      });
+    } catch (_) {
+      // The check below converts an unsupported override into a clear error.
+    }
+  }
+  if (navigatorObject && navigatorObject.hardwareConcurrency !== 1) {
+    throw new Error('Piper could not be restricted to one processor thread.');
+  }
+  // Piper already runs in a worker. Avoid a second worker pool on mobile Safari.
+  onnxRuntime.env.wasm.numThreads = 1;
+  onnxRuntime.env.wasm.initTimeout = 60000;
+}
+

piper-runtime.js

@@ -6,7 +6,9 @@ const pending = new Map();
 
 function getWorker() {
   if (worker) return worker;
-  worker = new Worker(workerUrl);
+  // ONNX Runtime resolves its WASM loader relative to the worker module URL.
+  // Keep the worker as ESM so import.meta.url remains available at runtime.
+  worker = new Worker(workerUrl, {type: 'module'});
   worker.onmessage = event => {
     const message = event.data || {};
     const request = pending.get(message.id);
@@ -15,8 +17,19 @@ function getWorker() {
       request.onProgress?.(message.progress);
     } else {
       pending.delete(message.id);
-      if (message.type === 'audio') request.resolve(new Blob([message.audio], {type: 'audio/x-wav'}));
+      if (message.type === 'audio') {
-      else request.reject(new Error(message.error || 'Piper-arbetaren misslyckades.'));
+        request.resolve(new Blob([message.audio], {type: 'audio/x-wav'}));
+      } else {
+        const error = new Error(message.error || 'Piper-arbetaren misslyckades.');
+        request.reject(error);
+        // TtsSession keeps a singleton even when ONNX initialization fails.
+        // Discard the whole worker so a player retry starts with a clean ONNX
+        // module and does not reuse a poisoned WASM initialization.
+        for (const queued of pending.values()) queued.reject(error);
+        pending.clear();
+        worker?.terminate();
+        worker = null;
+      }
     }
   };
   worker.onerror = event => {

piper-worker.js

@@ -1,29 +1,59 @@
 import {TtsSession} from '@mintplex-labs/piper-tts-web';
+import * as onnxRuntime from 'onnxruntime-web';
+import {trackDownloadProgress} from './piper-download-progress.mjs';
 import {localPiperModelUrl} from './piper-model-routing.mjs';
-import {createOnnxWasmPaths} from './piper-onnx-config.mjs';
+import {configureOnnxRuntime, createOnnxWasmPaths} from './piper-onnx-config.mjs';
 
 const VOICE_ID = 'sv_SE-nst-medium';
 const ASSET_ROOT = '/static/piper-wasm-v1';
 const localFetch = self.fetch.bind(self);
 
+function reportStage(id, stage, details = {}) {
+  if (Number.isSafeInteger(id)) self.postMessage({id, type: 'progress', progress: {stage, ...details}});
+}
+
 // Keep the TTS library's OPFS cache logic, but serve models/config from the
 // same-origin static asset service instead of its built-in external model URL.
-self.fetch = (resource, options) => {
+self.fetch = async (resource, options) => {
   const requestedUrl = resource instanceof Request ? resource.url : String(resource);
   const localModelUrl = localPiperModelUrl(requestedUrl, self.location.origin);
-  if (!localModelUrl) return localFetch(resource, options);
+  if (!localModelUrl) {
+    const runtimeAsset = requestedUrl.includes('/static/piper-wasm-v1/onnx/');
+    const runtimeFile = runtimeAsset ? new URL(requestedUrl, self.location.origin).pathname.split('/').pop() : undefined;
+    if (activeRequestId && runtimeAsset) {
+      reportStage(activeRequestId, 'loading-runtime-assets', {file: runtimeFile});
+    }
+    const response = await localFetch(resource, options);
+    if (!activeRequestId || !runtimeAsset) return response;
+    reportStage(activeRequestId, 'reading-runtime-assets', {file: runtimeFile});
+    return trackDownloadProgress(response, {
+      id: activeRequestId,
+      asset: 'runtime',
+      file: runtimeFile,
+      postMessage: message => self.postMessage(message),
+    });
+  }
+  const isModel = localModelUrl.endsWith('.onnx');
+  if (activeRequestId) reportStage(activeRequestId, isModel ? 'loading-model' : 'loading-model-info');
   const redirected = resource instanceof Request ? new Request(localModelUrl, resource) : localModelUrl;
-  return localFetch(redirected, options);
+  const response = await localFetch(redirected, options);
+  if (!activeRequestId || !isModel) return response;
+  reportStage(activeRequestId, 'reading-model');
+  return trackDownloadProgress(response, {
+    id: activeRequestId,
+    postMessage: message => self.postMessage(message),
+  });
 };
 
 let sessionPromise;
 let inferenceQueue = Promise.resolve();
+let activeRequestId = null;
 
-async function getSession(onProgress) {
+async function getSession() {
   if (!sessionPromise) {
+    configureOnnxRuntime(onnxRuntime);
     sessionPromise = TtsSession.create({
       voiceId: VOICE_ID,
-      progress: onProgress,
       wasmPaths: {
         onnxWasm: createOnnxWasmPaths(self.location.origin),
         piperData: `${ASSET_ROOT}/piper/piper_phonemize.data`,
@@ -40,13 +70,18 @@ async function getSession(onProgress) {
 async function synthesizeMessage(event) {
   const {id, text} = event.data || {};
   if (!Number.isSafeInteger(id) || typeof text !== 'string') return;
+  activeRequestId = id;
+  reportStage(id, 'loading-runtime');
   try {
-    const session = await getSession(progress => self.postMessage({id, type: 'progress', progress}));
+    const session = await getSession();
+    reportStage(id, 'model-ready');
     const blob = await session.predict(text);
     const audio = await blob.arrayBuffer();
     self.postMessage({id, type: 'audio', audio}, [audio]);
   } catch (error) {
     self.postMessage({id, type: 'error', error: String(error?.message || error)});
+  } finally {
+    activeRequestId = null;
   }
 }
 

scripts/build-piper.mjs

@@ -25,7 +25,7 @@ await build({
   entryPoints: [resolve(root, 'piper-worker.js')],
   outfile: join(workerRoot, 'piper-worker.js'),
   bundle: true,
-  format: 'iife',
+  format: 'esm',
   platform: 'browser',
   target: ['es2022'],
   external: ['fs', 'path'],

scripts/check-frontend.sh

@@ -28,7 +28,13 @@ grep -q "retry.textContent = 'Läs senaste repliken'" index.html
 grep -q "location.pathname !== '/admin'" index.html
 grep -q "if (options.speak !== false && location.pathname !== '/admin')" index.html
 grep -q 'id="microphone" aria-pressed="false"' index.html
+grep -q 'type="submit" id="send-message">Skicka</button>' index.html
 grep -q 'id="voice-status" role="status" aria-live="polite"' index.html
+grep -q 'id="speech-progress" aria-label="Nedladdning av svensk röstmodell"' index.html
+grep -q 'id="speech-progress-value"' index.html
+grep -q 'MB hämtade' index.html
+grep -q 'loading-runtime-assets' piper-worker.js
+grep -q 'Röstmodellen är inläst' voice.js
 grep -q "window.GameVoice.createVoiceController" index.html
 grep -q "addVoiceButton(item, 'Testa ljudet'" index.html
 grep -q 'Jag förstår – starta mikrofonen' index.html
@@ -45,11 +51,17 @@ grep -q 'COPY public/tts/piper-wasm-v1/' Dockerfile
 grep -q 'build:piper' .gitea/workflows/publish.yaml
 grep -q 'Piper' piper-runtime.js
 grep -q 'sv_SE-nst-medium' piper-worker.js
-grep -q 'new Worker(workerUrl)' piper-runtime.js
+grep -q "new Worker(workerUrl, {type: 'module'})" piper-runtime.js
 grep -q 'worker.js?v=' piper-runtime.js
 grep -q 'worker.onmessageerror' piper-runtime.js
 grep -q 'localPiperModelUrl' piper-worker.js
+grep -q 'trackDownloadProgress' piper-worker.js
+grep -q 'new ReadableStream' piper-download-progress.mjs
 grep -q 'createOnnxWasmPaths(self.location.origin)' piper-worker.js
+grep -q 'configureOnnxRuntime(onnxRuntime)' piper-worker.js
+grep -q 'numThreads = 1' piper-onnx-config.mjs
+grep -q "hardwareConcurrency'" piper-onnx-config.mjs
+grep -q 'Piper could not be restricted to one processor thread' piper-onnx-config.mjs
 grep -q '/static/piper-wasm-v1/onnx/' piper-onnx-config.mjs
 grep -q 'PIPER_MODEL_ORIGIN' piper-model-routing.mjs
 grep -q '/static/piper-wasm-v1/voices/' piper-model-routing.mjs
@@ -69,6 +81,12 @@ grep -q "Säg till Robin" index.html
 grep -q "result.intent === 'move' || result.intent === 'meet'" index.html
 grep -q 'dialogue_temporarily_unavailable:' index.html
 grep -q 'id="admin-view"' index.html
+grep -q 'id="play-layout"' index.html
+grep -q 'id="debug-panel"' index.html
+grep -q "request('/api/admin/self/trace?limit=200')" index.html
+grep -q 'function renderDecisionTrace' index.html
+grep -q 'JSON.stringify(group, null, 2)' index.html
+grep -q 'debug-enabled' index.html
 grep -q '/api/admin/players?' index.html
 grep -q "request('/api/admin/prompts'" index.html
 grep -q "request('/api/admin/rules'" index.html
@@ -84,8 +102,8 @@ if grep -Eq 'id="(new-character|world-setup|shop|buy-offer|balance|inventory|pla
   echo 'The active player UI must not contain permanent data panels, forms, or action buttons.' >&2
   exit 1
 fi
-if sed -n '/<section id="play"/,/^    <\/section>/p' index.html | grep '<button' | grep -v 'id="microphone"' >/dev/null; then
+if sed -n '/<section id="play"/,/^    <\/section>/p' index.html | grep '<button' | grep -Ev 'id="(microphone|send-message)"' >/dev/null; then
-  echo 'Only the microphone control may appear beside the game text input.' >&2
+  echo 'Only the send and microphone controls may appear beside the game text input.' >&2
   exit 1
 fi
 

tests/piper-download-progress.test.cjs

@@ -0,0 +1,59 @@
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+test('model response progress forwards each downloaded chunk and preserves the response', async () => {
+  const {trackDownloadProgress} = await import('../piper-download-progress.mjs');
+  const source = new ReadableStream({
+    start(controller) {
+      controller.enqueue(new Uint8Array([1, 2]));
+      controller.enqueue(new Uint8Array([3, 4, 5]));
+      controller.close();
+    },
+  });
+  const response = new Response(source, {headers: {'content-length': '5'}});
+  const messages = [];
+  const tracked = trackDownloadProgress(response, {id: 7, postMessage: message => messages.push(message)});
+
+  assert.deepEqual([...new Uint8Array(await tracked.arrayBuffer())], [1, 2, 3, 4, 5]);
+  assert.deepEqual(messages.map(message => message.progress), [
+    {asset: 'model', loaded: 2, total: 5},
+    {asset: 'model', loaded: 5, total: 5},
+  ]);
+  assert.ok(messages.every(message => message.id === 7 && message.type === 'progress'));
+});
+
+test('model response progress works when content length is absent', async () => {
+  const {trackDownloadProgress} = await import('../piper-download-progress.mjs');
+  const source = new Response(new Uint8Array([1, 2, 3]));
+  const messages = [];
+  const tracked = trackDownloadProgress(source, {
+    id: 9,
+    asset: 'runtime',
+    file: 'runtime.wasm',
+    postMessage: message => messages.push(message),
+  });
+
+  assert.equal((await tracked.arrayBuffer()).byteLength, 3);
+  assert.deepEqual(messages
+    .map(message => message.progress)
+    .filter(progress => Number.isFinite(progress.loaded)),
+  [{asset: 'runtime', file: 'runtime.wasm', loaded: 3, total: 0}]);
+});
+
+test('runtime asset completion reports that initialization follows the download', async () => {
+  const {trackDownloadProgress} = await import('../piper-download-progress.mjs');
+  const response = new Response(new Uint8Array([1, 2]), {headers: {'content-length': '2'}});
+  const messages = [];
+  const tracked = trackDownloadProgress(response, {
+    id: 10,
+    asset: 'runtime',
+    file: 'ort-wasm-simd-threaded.wasm',
+    postMessage: message => messages.push(message),
+  });
+
+  await tracked.arrayBuffer();
+  assert.deepEqual(messages.at(-1).progress, {
+    stage: 'initializing-runtime',
+    file: 'ort-wasm-simd-threaded.wasm',
+  });
+});

tests/piper-onnx-config.test.cjs

@@ -13,3 +13,20 @@ test('ONNX Runtime base URL rejects an invalid worker origin', async () => {
   const {createOnnxWasmPaths} = await import('../piper-onnx-config.mjs');
   assert.throws(() => createOnnxWasmPaths('undefined'), TypeError);
 });
+
+test('Piper and ONNX Runtime stay on one thread even though Piper overwrites ONNX settings', async () => {
+  const {configureOnnxRuntime} = await import('../piper-onnx-config.mjs');
+  const navigatorObject = {hardwareConcurrency: 8};
+  const previousNavigator = globalThis.navigator;
+  Object.defineProperty(globalThis, 'navigator', {configurable: true, value: navigatorObject});
+  const runtime = {env: {wasm: {numThreads: 0, initTimeout: 0}}};
+  try {
+    configureOnnxRuntime(runtime);
+    assert.equal(navigatorObject.hardwareConcurrency, 1);
+    assert.equal(runtime.env.wasm.numThreads, 1);
+    assert.equal(runtime.env.wasm.initTimeout, 60000);
+  } finally {
+    if (previousNavigator === undefined) delete globalThis.navigator;
+    else Object.defineProperty(globalThis, 'navigator', {configurable: true, value: previousNavigator});
+  }
+});

tests/piper-worker-format.test.cjs

@@ -0,0 +1,19 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const {readFile} = require('node:fs/promises');
+const {join} = require('node:path');
+
+test('Piper worker is built and started as an ES module', async () => {
+  const [buildScript, runtime] = await Promise.all([
+    readFile(join(__dirname, '..', 'scripts', 'build-piper.mjs'), 'utf8'),
+    readFile(join(__dirname, '..', 'piper-runtime.js'), 'utf8'),
+  ]);
+  assert.match(buildScript, /outfile: join\(workerRoot, 'piper-worker\.js'\),\s*bundle: true,\s*format: 'esm'/);
+  assert.match(runtime, /new Worker\(workerUrl, \{type: 'module'\}\)/);
+});
+
+test('Piper runtime discards a worker after a failed initialization for a clean retry', async () => {
+  const runtime = await readFile(join(__dirname, '..', 'piper-runtime.js'), 'utf8');
+  assert.match(runtime, /TtsSession keeps a singleton even when ONNX initialization fails/);
+  assert.match(runtime, /worker\?\.terminate\(\);\s*worker = null;/);
+});

tests/voice.test.cjs

@@ -26,6 +26,7 @@ function makeHarness({supported = true, tts = true, piper = false, onTranscript
     constructor(text) { this.text = text; utterances.push(this); }
   }
   const audioSources = [];
+  const piperProgressCallbacks = [];
   class AudioContext {
     constructor() { this.state = 'running'; this.destination = {}; }
     resume() { this.state = 'running'; return Promise.resolve(); }
@@ -49,7 +50,10 @@ function makeHarness({supported = true, tts = true, piper = false, onTranscript
     SpeechSynthesisUtterance: tts ? Utterance : undefined,
     SpeechRecognition: supported ? Recognition : undefined,
     AudioContext,
-    GamePiper: piper ? {synthesize: () => Promise.resolve({arrayBuffer: () => Promise.resolve(new ArrayBuffer(8))})} : undefined,
+    GamePiper: piper ? {synthesize: (_text, onProgress) => {
+      piperProgressCallbacks.push(onProgress);
+      return Promise.resolve({arrayBuffer: () => Promise.resolve(new ArrayBuffer(8))});
+    }} : undefined,
   };
   vm.runInNewContext(source, {window, globalThis: window, Promise, String, Math, Object});
   const controller = window.GameVoice.createVoiceController({
@@ -58,7 +62,7 @@ function makeHarness({supported = true, tts = true, piper = false, onTranscript
     onTranscript,
   });
   return {
-    controller, recognitions, utterances, synthesis, states, timers, audioSources,
+    controller, recognitions, utterances, synthesis, states, timers, audioSources, piperProgressCallbacks,
     runTimer(delay) {
       const match = [...timerDelays.entries()].find(([, value]) => value === delay);
       if (!match) throw new Error(`No timer found with delay ${delay}`);
@@ -250,6 +254,24 @@ test('Piper WASM output uses the unlocked audio context and starts only after lo
   assert.equal(h.controller.getState(), 'IDLE');
 });
 
+test('Piper model download progress is reported as a bounded percentage', async () => {
+  const h = makeHarness({piper: true});
+  h.controller.activateFromUserGesture();
+  h.controller.speak('Ett svar från Piper.');
+  await new Promise(resolve => setImmediate(resolve));
+  h.piperProgressCallbacks[0]({stage: 'loading-model'});
+  assert.match(h.states.at(-1).message, /Ansluter till servern/);
+  h.piperProgressCallbacks[0]({asset: 'runtime', file: 'ort-wasm-simd-threaded.wasm', loaded: 5 * 1024 * 1024, total: 10 * 1024 * 1024});
+  assert.match(h.states.at(-1).message, /ort-wasm-simd-threaded\.wasm: 50 procent/);
+  h.piperProgressCallbacks[0]({loaded: 31_500_000, total: 63_000_000});
+  assert.equal(h.states.at(-1).state, 'PROCESSING');
+  assert.match(h.states.at(-1).message, /50 procent/);
+  h.piperProgressCallbacks[0]({loaded: 90_000_000, total: 63_000_000});
+  assert.match(h.states.at(-1).message, /100 procent/);
+  h.piperProgressCallbacks[0]({loaded: 10 * 1024 * 1024, total: 0});
+  assert.match(h.states.at(-1).message, /10 MB hämtade/);
+});
+
 test('Piper output keeps per-character pitch and rate stable', async () => {
   const h = makeHarness({piper: true});
   h.controller.activateFromUserGesture();

voice.js

@@ -250,13 +250,58 @@
         setState('IDLE', 'Piper tog för lång tid på sig. Dialogen finns kvar som text. Tryck på Läs senaste repliken för att försöka igen.');
       }, 180000);
 
-      let lastProgress = -1;
+      let lastProgressPercent = -1;
+      let lastProgressMegabytes = -1;
+      let lastProgressResource = '';
       const progress = event => {
-        if (token !== generation || !event?.total) return;
+        if (token !== generation) return;
-        const percent = Math.min(100, Math.floor((event.loaded / event.total) * 100));
+        const resource = `${event?.asset || 'model'}:${event?.file || ''}`;
-        if (percent === lastProgress) return;
+        if (resource !== lastProgressResource) {
-        lastProgress = percent;
+          lastProgressResource = resource;
-        setState('PROCESSING', `Hämtar svensk röstmodell till enheten: ${percent} procent.`);
+          lastProgressPercent = -1;
+          lastProgressMegabytes = -1;
+        }
+        if (event?.asset === 'runtime' && Number.isFinite(event.loaded) && event.loaded >= 0) {
+          const file = /^[\w.-]+$/.test(event.file || '') ? event.file : 'WebAssembly-fil';
+          if (Number.isFinite(event.total) && event.total > 0) {
+            const percent = Math.max(0, Math.min(100, Math.floor((event.loaded / event.total) * 100)));
+            if (percent === lastProgressPercent) return;
+            lastProgressPercent = percent;
+            setState('PROCESSING', `Hämtar WebAssembly-filen ${file}: ${percent} procent.`);
+          } else {
+            const megabytes = Math.floor((event.loaded / (1024 * 1024)) * 10) / 10;
+            if (megabytes === lastProgressMegabytes) return;
+            lastProgressMegabytes = megabytes;
+            setState('PROCESSING', `Hämtar WebAssembly-filen ${file}: ${megabytes.toLocaleString('sv-SE')} MB hämtade.`);
+          }
+          return;
+        }
+        const stages = {
+          'loading-runtime': 'Laddar WebAssembly-motorn för svensk uppläsning.',
+          'loading-runtime-assets': `Hämtar WebAssembly-filen ${event?.file || 'från servern'}.`,
+          'reading-runtime-assets': `Läser in WebAssembly-filen ${event?.file || ''}.`,
+          'initializing-runtime': `Startar WebAssembly-motorn efter nedladdning av ${event?.file || 'filen'}.`,
+          'loading-model-info': 'Hämtar information om den svenska röstmodellen.',
+          'loading-model': 'Ansluter till servern för att hämta den svenska röstmodellen.',
+          'reading-model': 'Läser in den svenska röstmodellen.',
+          'model-ready': 'Röstmodellen är inläst. Skapar uppläsningen.',
+        };
+        if (stages[event?.stage]) {
+          setState('PROCESSING', stages[event.stage]);
+          return;
+        }
+        if (!Number.isFinite(event?.loaded) || event.loaded < 0) return;
+        if (Number.isFinite(event.total) && event.total > 0) {
+          const percent = Math.max(0, Math.min(100, Math.floor((event.loaded / event.total) * 100)));
+          if (percent === lastProgressPercent) return;
+          lastProgressPercent = percent;
+          setState('PROCESSING', `Hämtar svensk röstmodell till enheten: ${percent} procent.`);
+          return;
+        }
+        const megabytes = Math.floor((event.loaded / (1024 * 1024)) * 10) / 10;
+        if (megabytes === lastProgressMegabytes) return;
+        lastProgressMegabytes = megabytes;
+        setState('PROCESSING', `Hämtar svensk röstmodell till enheten: ${megabytes.toLocaleString('sv-SE')} MB hämtade.`);
       };
 
       Promise.resolve()