fix(ci): pulseaudio headers, and an ASCII release payload

Linux got past pipewire and stopped on pulse/pulseaudio.h — the module
compiles both backends, so both sets of headers are needed.

Windows reached the upload and Gitea rejected the release creation with HTTP
422, 'invalid UTF-8 within /name': the JSON body carried accented text and the
Windows runner's shell mangles the encoding on the way out. The payload is now
ASCII, with a comment saying why, so it does not get 'improved' back into
Portuguese.

.github/workflows/build-windows.yml

@@ -0,0 +1,97 @@
+# Caminho rápido: só Windows x64, disparado à mão.
+#
+# O `release.yml` continua sendo o release de verdade (todas as plataformas,
+# publica release e alimenta o electron-updater). Este aqui existe para quando
+# você só quer um .exe para testar, sem marcar versão.
+#
+# Arquivo separado de propósito: o release.yml veio do upstream e recebe merges;
+# mexer nele criaria conflito a cada atualização.
+name: Build Windows (rápido)
+
+on:
+  workflow_dispatch:
+    inputs:
+      arch:
+        description: Arquitetura
+        required: false
+        default: x64
+        type: choice
+        options: [x64, arm64]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    # windows-2022, não windows-latest: a imagem latest traz o Visual Studio 18,
+    # que o node-gyp embutido no electron-rebuild não detecta ao compilar os
+    # módulos nativos. Mesma razão documentada no release.yml.
+    runs-on: windows-2022
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v5.0.0
+        with:
+          version: 10.34.3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0
+        with:
+          node-version: 20
+          cache: pnpm
+
+      # ~100MB de binários do Electron e das ferramentas do NSIS, baixados a
+      # cada execução sem isto. É o maior ganho depois de cortar o arm64.
+      - name: Cache Electron binaries
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~\AppData\Local\electron\Cache
+            ~\AppData\Local\electron-builder\Cache
+          key: electron-cache-${{ runner.os }}-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: electron-cache-${{ runner.os }}-
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build shared package
+        run: pnpm --filter @backspace/shared build
+
+      # O postinstall termina em `|| console.warn` para que quem não tem
+      # ferramentas de build consiga instalar. No CI isso transforma falha em
+      # sucesso silencioso: o instalador sai sem o módulo nativo e o app
+      # compartilha tela sem som, sem erro nenhum. Então verifica-se o
+      # resultado em vez de confiar no código de saída.
+      - name: Verify native audio module compiled
+        shell: bash
+        run: |
+          found=$(find node_modules/.pnpm -path '*electron-native-screenshare*' -name '*.node' 2>/dev/null | head -5)
+          if [ -z "$found" ]; then
+            echo "::error::electron-native-screenshare has no compiled .node — the installer would ship without system-audio capture"
+            find node_modules/.pnpm -maxdepth 1 -name 'electron-native-screenshare*' -printf '%p\n' 2>/dev/null || true
+            exit 1
+          fi
+          echo "OK:"; echo "$found"
+
+      - name: Compile desktop TypeScript
+        working-directory: packages/desktop
+        run: pnpm exec tsc
+
+      # --publish never: sem release, sem precisar de tag nem bump de versão.
+      # O instalador sai como artefato desta execução.
+      - name: Build installer
+        working-directory: packages/desktop
+        run: pnpm exec electron-builder --win --${{ inputs.arch || 'x64' }} --publish never
+        env:
+          CSC_IDENTITY_AUTO_DISCOVERY: "false"
+
+      - name: Upload installer
+        uses: actions/upload-artifact@v4
+        with:
+          name: backspace-windows-${{ inputs.arch || 'x64' }}
+          path: packages/desktop/dist-electron/*.exe
+          retention-days: 14
+          if-no-files-found: error

.github/workflows/publish-gitea.yml

@@ -0,0 +1,183 @@
+# Compila no GitHub, publica no Gitea.
+#
+# O GitHub entra só como máquina de build — é dele que vêm os runners Windows
+# de que o módulo nativo de áudio precisa. A distribuição fica no Gitea, que
+# serve os arquivos a qualquer um: assim o electron-updater não precisa de
+# credencial embutida no app, o que aconteceria com um repositório privado no
+# GitHub.
+name: Publicar no Gitea
+
+on:
+  push:
+    tags: ['v*']
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Tag a publicar (ex. v1.1.0)
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2022
+            args: --win --x64
+          - os: ubuntu-latest
+            args: --linux --x64
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+
+      - name: Install Linux build dependencies
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libx11-dev libxtst-dev libxt-dev \
+            libxkbcommon-dev libxkbcommon-x11-dev libxkbfile-dev \
+            libxrandr-dev libxinerama-dev libx11-xcb-dev \
+            libpipewire-0.3-dev libpulse-dev
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v5.0.0
+        with:
+          version: 10.34.3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0
+        with:
+          node-version: 20
+          cache: pnpm
+
+      - name: Cache Electron binaries
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/electron
+            ~/.cache/electron-builder
+            ~\AppData\Local\electron\Cache
+            ~\AppData\Local\electron-builder\Cache
+          key: electron-cache-${{ runner.os }}-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: electron-cache-${{ runner.os }}-
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build shared package
+        run: pnpm --filter @backspace/shared build
+
+      # O postinstall termina em `|| console.warn` para quem não tem ferramentas
+      # de build. No CI isso esconde falha: o instalador sairia sem captura de
+      # áudio do sistema e ninguém saberia. Verifica-se o resultado.
+      - name: Verify native audio module compiled
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          found=$(find node_modules/.pnpm -path '*electron-native-screenshare*' -name '*.node' | head -5)
+          [ -n "$found" ] || { echo "::error::sem .node compilado — instalador sairia sem áudio do sistema"; exit 1; }
+          echo "$found"
+
+      - name: Compile desktop TypeScript
+        working-directory: packages/desktop
+        run: pnpm exec tsc
+
+      # --publish never: o electron-builder não sabe enviar para o Gitea. Ele
+      # gera os instaladores e o latest.yml (o índice que o app consulta), e o
+      # passo seguinte faz o upload.
+      - name: Build installers
+        working-directory: packages/desktop
+        run: pnpm exec electron-builder ${{ matrix.args }} --publish never
+        env:
+          CSC_IDENTITY_AUTO_DISCOVERY: "false"
+
+      - name: Upload to Gitea release
+        shell: bash
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          GITEA_API: https://git.resenha.website/api/v1/repos/devsyncwrld/backspace
+          TAG: latest
+        run: |
+          set -uo pipefail
+          if [ -z "${GITEA_TOKEN:-}" ]; then
+            echo "::error::segredo GITEA_TOKEN não configurado"
+            exit 1
+          fi
+
+          # Sem -f e imprimindo o corpo: a versão anterior usava `curl -sf`, que
+          # engole a resposta de erro, então uma falha aqui só aparecia como um
+          # JSONDecodeError sem dizer o motivo.
+          api() {
+            local method=$1 path=$2; shift 2
+            curl -s -w '\n%{http_code}' -X "$method" \
+              -H "Authorization: token $GITEA_TOKEN" "$GITEA_API$path" "$@"
+          }
+          body() { sed '$d' <<<"$1"; }
+          code() { tail -n1 <<<"$1"; }
+          # jq em vez de python embutido: um heredoc multilinha dentro de um
+          # bloco literal de YAML encerra o bloco na primeira linha sem recuo.
+          json_id() { jq -r '.id // empty'; }
+
+          find_release() {
+            local r; r=$(api GET "/releases/tags/$TAG")
+            [ "$(code "$r")" = "200" ] && body "$r" | json_id || echo ""
+          }
+
+          # O corpo do POST fica em ASCII de proposito: o shell do runner
+          # Windows corrompe UTF-8 na requisicao e o Gitea recusa com
+          # "invalid UTF-8 within /name" (HTTP 422).
+          ID=$(find_release)
+          if [ -z "$ID" ]; then
+            R=$(api POST "/releases" -H 'Content-Type: application/json' \
+                 -d "{\"tag_name\":\"$TAG\",\"name\":\"Latest build\",\"target_commitish\":\"main\",\"body\":\"Installers published automatically by CI.\"}")
+            if [ "$(code "$R")" = "201" ]; then
+              ID=$(body "$R" | json_id)
+              echo "release criada: $ID"
+            else
+              echo "criação retornou HTTP $(code "$R"): $(body "$R")"
+              # O outro job da matriz pode tê-la criado no mesmo instante.
+              ID=$(find_release)
+              [ -n "$ID" ] || { echo "::error::não foi possível obter nem criar a release"; exit 1; }
+              echo "release encontrada após corrida: $ID"
+            fi
+          else
+            echo "release existente: $ID"
+          fi
+
+          # Remove só os anexos que esta plataforma vai repor, para os dois jobs
+          # não apagarem o trabalho um do outro.
+          R=$(api GET "/releases/$ID/assets")
+          if [ "$(code "$R")" = "200" ]; then
+            body "$R" | jq -r '.[] | "\(.id) \(.name)"' | while read -r aid aname; do
+              case "$aname" in
+                ${{ runner.os == 'Windows' && '*.exe|latest.yml' || '*.AppImage|*.deb|latest-linux.yml' }})
+                  echo "removendo anexo antigo: $aname"
+                  api DELETE "/releases/$ID/assets/$aid" > /dev/null ;;
+              esac
+            done
+          fi
+
+          shopt -s nullglob
+          sent=0
+          for f in packages/desktop/dist-electron/*.exe \
+                   packages/desktop/dist-electron/*.AppImage \
+                   packages/desktop/dist-electron/*.deb \
+                   packages/desktop/dist-electron/latest*.yml; do
+            name=$(basename "$f")
+            R=$(api POST "/releases/$ID/assets?name=$name" -F "attachment=@$f")
+            if [ "$(code "$R")" != "201" ]; then
+              echo "::error::falha ao enviar $name — HTTP $(code "$R"): $(body "$R")"
+              exit 1
+            fi
+            echo "enviado: $name"
+            sent=$((sent+1))
+          done
+          [ "$sent" -gt 0 ] || { echo "::error::o build não produziu instaladores"; exit 1; }
+          echo "$sent arquivo(s) publicados"

.github/workflows/release.yml

@@ -14,22 +14,26 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          # macOS — universal build (arm64 + x64) on Apple Silicon runner
+          # Fork: só as plataformas que o grupo usa. Windows arm64 saiu porque
-          - os: macos-latest
+          # dobrava o job mais lento (duas distribuições do Electron, módulos
-            args: --mac --arm64 --x64
+          # nativos compilados duas vezes) e ninguém roda Windows em ARM.
+          # Linux arm64 saiu pelo mesmo motivo. Com o arm64 fora, o passo que
+          # instalava o fpm nativo perdeu a razão de existir: ele só era
+          # necessário porque o fpm embutido no electron-builder é x86_64 e
+          # falhava no runner arm64.
+          # macOS removido neste fork: ninguém do grupo usa, e o runner macOS
+          # é cobrado a 10x num repositório privado — era a plataforma mais cara
+          # da matriz, compilada em toda tag para zero usuários.
           # Windows — x64 + arm64 on x64 runner.
           # Pinned to windows-2022 (VS 2022 / v17): the windows-latest image
           # ships VS "18", which the node-gyp bundled with electron-rebuild
           # cannot detect ("unknown version undefined") when compiling
           # uiohook-napi in postinstall.
           - os: windows-2022
-            args: --win --x64 --arm64
+            args: --win --x64
           # Linux — x64 on x64 runner
           - os: ubuntu-latest
             args: --linux --x64
-          # Linux — arm64 on arm64 runner
-          - os: ubuntu-24.04-arm
-            args: --linux --arm64
 
     runs-on: ${{ matrix.os }}
 
@@ -59,17 +63,6 @@ jobs:
             libxkbcommon-dev libxkbcommon-x11-dev libxkbfile-dev \
             libxrandr-dev libxinerama-dev libx11-xcb-dev
 
-      - name: Install fpm for .deb packaging
-        if: runner.os == 'Linux'
-        # electron-builder bundles an x86_64-only fpm; on the arm64 runner it
-        # aborts the .deb target with "cannot execute binary file: Exec format
-        # error". Install fpm natively and set USE_SYSTEM_FPM (below) so both
-        # arches package their .deb with a host-native fpm. ruby-dev + make are
-        # needed for fpm's native gem dependencies.
-        run: |
-          sudo apt-get install -y ruby ruby-dev build-essential
-          sudo gem install --no-document fpm
-
       - name: Setup pnpm
         uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v5.0.0
         with:
@@ -97,7 +90,3 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           CSC_IDENTITY_AUTO_DISCOVERY: "false"
-          # Use the host-native fpm installed above instead of electron-builder's
-          # bundled x86_64 fpm (which can't run on the arm64 runner). No-op on
-          # macOS/Windows, which don't build .deb.
-          USE_SYSTEM_FPM: "true"

docs/build-desktop.md

@@ -0,0 +1,56 @@
+# Gerar o instalador do app desktop
+
+O workflow **`.github/workflows/release.yml`** (herdado do upstream) já compila
+para macOS, Windows e Linux e publica os instaladores como release. Ele dispara
+ao empurrar uma tag `v*`.
+
+Não foi preciso escrever workflow novo — foi preciso **adaptá-lo ao fork**.
+
+## Por que GitHub e não Gitea
+
+O Gitea desta instância não tem Actions habilitado, e mesmo habilitado ele
+**não oferece máquinas hospedadas**: seria preciso registrar um PC Windows
+como runner e mantê-lo ligado. O GitHub fornece runners Windows prontos, que é
+exatamente o que falta — o módulo nativo do compartilhamento de áudio usa
+WASAPI e só compila no Windows, com o compilador da Microsoft.
+
+O Gitea continua sendo o repositório principal. O GitHub entra apenas como
+espelho para compilar.
+
+## Passos (uma vez)
+
+1. Criar um repositório no GitHub — o `electron-builder.yml` está apontado para
+   `syncwrld/resenhacord`. **Se o seu for outro nome, ajuste lá.**
+2. Adicionar o espelho e empurrar:
+   ```
+   cd /opt/backspace
+   git remote add github git@github.com:syncwrld/resenhacord.git
+   git push github main
+   ```
+3. Marcar uma versão e empurrar a tag — é ela que dispara a compilação:
+   ```
+   git tag v1.0.1 && git push github v1.0.1
+   ```
+4. Os instaladores aparecem na aba Releases do GitHub em ~15 minutos.
+
+## O que isso resolve de quebra
+
+O `electron-updater` já estava instalado no projeto mas **sem feed** — o app
+não se atualizava sozinho. Como o `publish` agora aponta para as releases do
+fork, o app passa a encontrar versões novas por conta própria. Ninguém do grupo
+precisa reinstalar na mão de novo.
+
+## Adaptações feitas para o fork
+
+| O quê | Por quê |
+|---|---|
+| `publish.owner` → `syncwrld` | Apontava para o repositório do upstream |
+| `postinstall` reconstrói também `electron-native-screenshare` | Rodava `electron-rebuild` só no `uiohook-napi`. O módulo novo seria compilado para a ABI do Node em vez da do Electron e falharia ao carregar — e como o carregamento degrada em silêncio, o sintoma seria "compartilha sem som", sem erro visível |
+| Nota sobre `asarUnpack` | O `uiohook-napi` tem `build/` excluído do asar porque distribui binários prontos. O módulo novo **não** distribui: `build/Release/*.node` é a única cópia e não pode ser excluída |
+
+## Detalhe herdado que vale preservar
+
+O runner do Windows está fixado em `windows-2022`, não `windows-latest`. O
+comentário no workflow explica: a imagem `latest` traz o Visual Studio 18, que
+o node-gyp embutido no `electron-rebuild` não detecta ("unknown version
+undefined"). Não mude isso sem testar.

docs/roadmap-resenha.md

@@ -84,7 +84,7 @@ modais de convite · configurações restantes · telas de erro
 | Problema | Causa provável | Correção |
 |---|---|---|
 | **Enviar som ao soundboard não funciona no app desktop** (funciona no navegador) | `SoundboardPopover` pede o nome do som com `window.prompt`, que o **Electron não implementa** — não abre nada e devolve vazio, então o fluxo aborta em silêncio, sem erro. `window.prompt` aparece em exatamente um lugar no projeto: esse. O resto do código já o evitava | Trocar por um campo de texto dentro do próprio popover (ou um modal reutilizável). Some o prompt e passa a funcionar igual nos dois. **Vale criar o modal de entrada genérico**, já que não existe nenhum e outras features vão precisar |
-| **Eco absurdo ao compartilhar tela com som** (app desktop) | O `loopback` do Electron captura a mistura de saída do sistema **inteiro**, que inclui o próprio Backspace tocando a voz dos outros. Essa voz volta para eles dentro da transmissão, com atraso. Não é eco acústico — é digital, então **fone não resolve**. As constraints do web (`restrictOwnAudio`) nunca chegam: o handler ignora o `_request` e monta o stream a partir do enum. É também por isso que `shareAudio` já vinha desligado por padrão no app | Sem solução limpa no Electron: nem `loopback` nem `loopbackWithMute` excluem o áudio do próprio app. Opções reais na seção abaixo |
+| **Eco absurdo ao compartilhar tela com som** (app desktop) | O `loopback` do Electron captura a mistura de saída do sistema **inteiro**, que inclui o próprio Backspace tocando a voz dos outros. Essa voz volta para eles dentro da transmissão, com atraso. Não é eco acústico — é digital, então **fone não resolve**. As constraints do web (`restrictOwnAudio`) nunca chegam: o handler ignora o `_request` e monta o stream a partir do enum. É também por isso que `shareAudio` já vinha desligado por padrão no app | **Implementado (2026-09-01), não testado.** Trocado por `electron-native-screenshare`: captura com isolamento por processo — só a janela compartilhada (include) ou tudo menos este app (exclude). O PCM vai do processo principal ao renderer por IPC e vira faixa publicada no LiveKit. **Exige gerar instalador novo e reinstalar**, e só pode ser confirmado numa máquina Windows |
 | **Bloco do Spotify dessincronizado** (mostra a faixa errada por um tempo) | Soma de duas esperas: a consulta roda a cada **20s** (`useSpotifyActivity`) e o envio pelo WebSocket ainda passa por um **debounce de 5s** no `activityStore`. Na pior hipótese os outros veem a música anterior por ~25s | Consultar de novo perto do fim da faixa (a duração é conhecida) em vez de só por intervalo fixo, e encurtar o debounce para esta fonte |
 | **Bloco do Spotify some sozinho** | Três caminhos apagam a atividade inteira: faixa **pausada** (`is_playing: false` devolve `null`), o **vão entre faixas** (o Spotify responde `204`) e qualquer falha transitória. Some e volta = a piscada que você viu | Manter a última faixa conhecida por alguns segundos antes de apagar, e enviar um estado *pausado* explícito em vez de sumir com o bloco |
 | **Barra de progresso errada / andando pausada** | Duas causas independentes: (1) o progresso é derivado de carimbos calculados com o relógio do **servidor** e desenhado contra o relógio de **quem olha** — se os relógios divergem, a barra fica deslocada; (2) a barra continua avançando localmente depois que a pessoa pausa, até a próxima consulta | Enviar o horário do servidor junto no payload para o cliente corrigir a diferença, e congelar a barra quando o estado for pausado |

package.json

@@ -1,8 +1,8 @@
 {
   "name": "backspace",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "private": true,
-  "description": "Open, self-hosted communication platform — text, voice, video, and federation",
+  "description": "Open, self-hosted communication platform \u2014 text, voice, video, and federation",
   "license": "AGPL-3.0-only",
   "author": "Jannis Braun",
   "homepage": "https://github.com/TheZwiss/backspace",
@@ -32,8 +32,9 @@
   "pnpm": {
     "onlyBuiltDependencies": [
       "better-sqlite3",
-      "esbuild",
       "electron",
+      "electron-native-screenshare",
+      "esbuild",
       "sharp"
     ],
     "patchedDependencies": {

packages/desktop/electron-builder.yml

@@ -14,14 +14,27 @@ files:
   - "!**/node_modules/uiohook-napi/build/**"
   - "!**/node_modules/uiohook-napi/build.bak/**"
   - "!**/node_modules/uiohook-napi/bin/**"
+  # electron-native-screenshare has no prebuilds — build/Release/*.node is the
+  # only copy, so it must NOT be excluded the way uiohook-napi's is. asarUnpack
+  # below takes it out of the archive so the loader can find it.
 asarUnpack:
   - "**/*.node"
 npmRebuild: false
 afterPack: ./scripts/afterPack.js
 publish:
-  - provider: github
+  # Updates are served from this fork's own Gitea, not from GitHub.
-    owner: TheZwiss
+  #
-    repo: backspace
+  # GitHub is only the build machine — it has the Windows runners the native
+  # audio module needs. Its repository is private, and electron-updater against
+  # a private GitHub repo would need a token shipped inside the app, which is a
+  # leaked token. Gitea serves release assets to anyone, so no credential ends
+  # up in the installer.
+  #
+  # The tag is fixed at `latest` on purpose: electron-updater fetches
+  # latest.yml before it knows which version exists, so the URL cannot contain
+  # a version. CI replaces that release's assets on every publish.
+  - provider: generic
+    url: https://git.resenha.website/devsyncwrld/backspace/releases/download/latest/
 protocols:
   - name: Backspace
     schemes:

packages/desktop/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backspace/desktop",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "private": true,
   "license": "AGPL-3.0-only",
   "description": "Backspace",
@@ -18,9 +18,10 @@
     "clean": "rm -rf dist dist-electron",
     "test": "vitest run",
     "test:watch": "vitest",
-    "postinstall": "electron-rebuild -f -w uiohook-napi || node -e \"console.warn('[desktop] uiohook-napi native rebuild skipped - needs build tools (make, g++, python3). Only required to RUN the desktop app; the server, web client, and Docker image are unaffected.')\""
+    "postinstall": "electron-rebuild -f -w uiohook-napi,electron-native-screenshare || node -e \"console.warn('[desktop] uiohook-napi native rebuild skipped - needs build tools (make, g++, python3). Only required to RUN the desktop app; the server, web client, and Docker image are unaffected.')\""
   },
   "dependencies": {
+    "electron-native-screenshare": "^1.2.0",
     "electron-updater": "^6.3.0",
     "uiohook-napi": "^1.5.5"
   },

packages/desktop/src/main.ts

@@ -265,6 +265,102 @@ function applyLoginItemSettings(openAtLogin: boolean, startMinimized: boolean):
   }
 }
 
+// ─── Native system-audio capture ────────────────────────────────────────────
+//
+// Electron's own `audio: 'loopback'` captures the whole output mix, which
+// includes this app playing everyone else's voices — so those voices went back
+// out inside the screen share and every listener heard themselves. Not acoustic
+// echo: it is a digital copy of the output, so headphones never helped.
+//
+// This module captures with process-level isolation instead: only the shared
+// window (include mode), or everything except this app (exclude mode).
+interface NativeAudioMeta {
+  sampleRate: number;
+  channels: number;
+  bitsPerSample: number;
+  isFloat: boolean;
+}
+
+interface NativeScreenShareAudio {
+  startCapture(processId?: number, isIncludeMode?: boolean, onData?: (data: Buffer, meta: NativeAudioMeta) => void): boolean;
+  stopCapture(): boolean;
+  getPidFromWindowHandle(windowHandle: number): number;
+  isAvailable(): boolean;
+  getLoadError(): string | null;
+}
+
+let nativeAudio: NativeScreenShareAudio | null = null;
+try {
+  // Required lazily and defensively: a native module that fails to load must
+  // degrade to sharing without audio, never stop the app from starting.
+  nativeAudio = require('electron-native-screenshare') as NativeScreenShareAudio;
+  if (!nativeAudio.isAvailable()) {
+    console.warn('[Main:ScreenShare] Native audio unavailable:', nativeAudio.getLoadError());
+    nativeAudio = null;
+  }
+} catch (err) {
+  console.warn('[Main:ScreenShare] Native audio module missing:', err);
+  nativeAudio = null;
+}
+
+let nativeAudioActive = false;
+
+/**
+ * Windows and Linux hand desktopCapturer ids of the form `window:<handle>:<n>`.
+ * Recovering the handle lets us capture only that window's audio, which is
+ * better than excluding ourselves: a game's sound goes out, the rest of the
+ * desktop does not.
+ */
+function windowHandleFromSourceId(sourceId: string): number | null {
+  const match = /^window:(\d+)/.exec(sourceId);
+  if (!match) return null;
+  const handle = Number(match[1]);
+  return Number.isFinite(handle) && handle > 0 ? handle : null;
+}
+
+function startNativeAudioCapture(sourceId: string): boolean {
+  if (!nativeAudio || nativeAudioActive) return false;
+
+  let targetPid = process.pid;
+  let includeMode = false;
+
+  const handle = windowHandleFromSourceId(sourceId);
+  if (handle !== null) {
+    const pid = nativeAudio.getPidFromWindowHandle(handle);
+    // pid 0 means the handle did not resolve; fall back to excluding ourselves
+    // rather than capturing nothing.
+    if (pid > 0) {
+      targetPid = pid;
+      includeMode = true;
+    }
+  }
+
+  try {
+    const started = nativeAudio.startCapture(targetPid, includeMode, (data, meta) => {
+      if (!mainWindow || mainWindow.isDestroyed()) return;
+      mainWindow.webContents.send('native-audio-data', data, meta);
+    });
+    nativeAudioActive = started;
+    console.log('[Main:ScreenShare] Native audio', started ? 'started' : 'failed',
+      includeMode ? `(only pid ${targetPid})` : '(excluding self)');
+    return started;
+  } catch (err) {
+    console.error('[Main:ScreenShare] Native audio start failed:', err);
+    nativeAudioActive = false;
+    return false;
+  }
+}
+
+function stopNativeAudioCapture(): void {
+  if (!nativeAudio || !nativeAudioActive) return;
+  try {
+    nativeAudio.stopCapture();
+  } catch (err) {
+    console.warn('[Main:ScreenShare] Native audio stop failed:', err);
+  }
+  nativeAudioActive = false;
+}
+
 // ─── Tray Icon ──────────────────────────────────────────────────────────────
 
 function generateFallbackTrayIcon(): Electron.NativeImage {
@@ -594,6 +690,10 @@ function registerIpcHandlers(): void {
   ipcMain.handle('get-app-version', () => app.getVersion());
 
   // Screen share picker coordination (used by setDisplayMediaRequestHandler)
+  ipcMain.on('native-audio-stop', () => {
+    stopNativeAudioCapture();
+  });
+
   ipcMain.on('screen-share-selected', (_event, _sourceId: string | null, _shareAudio?: boolean) => {
     // Handled via ipcMain.once in the display media handler — this is just
     // a safety net to prevent unhandled-message warnings
@@ -953,7 +1053,19 @@ if (!gotTheLock) {
         //     `PulseaudioLoopbackForScreenShare` feature flag we enable above.
         //     Fails on PipeWire-only systems without pulse compat — the
         //     renderer catches that and toasts the user.
-        callback({ video: selected, ...(shareAudio ? { audio: 'loopback' } : {}) });
+        // Audio no longer rides on the Electron stream: `loopback` would put
+        // this app's own output (everyone else's voices) back into the share.
+        // The native module captures it separately, isolated by process, and
+        // the renderer turns it into the track LiveKit publishes.
+        if (shareAudio) {
+          const started = startNativeAudioCapture(sourceId);
+          if (!started) {
+            // Tell the renderer so it can say the share is going out silently,
+            // instead of the user assuming sound is included.
+            mainWindow?.webContents.send('native-audio-unavailable');
+          }
+        }
+        callback({ video: selected });
       } catch (err) {
         console.error('[Main:ScreenShare] Handler error:', err);
         // @ts-ignore — deny the request without crashing

packages/desktop/src/preload.ts

@@ -65,6 +65,24 @@ contextBridge.exposeInMainWorld('backspace', {
   onScreenShareSources: (callback: (sources: unknown[]) => void) => {
     ipcRenderer.on('screen-share-sources', (_event, sources) => callback(sources));
   },
+  // Raw PCM from the native capture. Arrives ~50x/second; the renderer turns it
+  // into a MediaStreamTrack for LiveKit.
+  onNativeAudioData: (callback: (data: ArrayBuffer, meta: { sampleRate: number; channels: number; bitsPerSample: number; isFloat: boolean }) => void) => {
+    const listener = (_event: unknown, data: Uint8Array, meta: { sampleRate: number; channels: number; bitsPerSample: number; isFloat: boolean }) => {
+      // Copied out of the transferred buffer: reusing it across IPC messages
+      // would let a later chunk overwrite one still being read.
+      callback(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer, meta);
+    };
+    ipcRenderer.on('native-audio-data', listener);
+    return () => ipcRenderer.off('native-audio-data', listener);
+  },
+  onNativeAudioUnavailable: (callback: () => void) => {
+    const listener = () => callback();
+    ipcRenderer.on('native-audio-unavailable', listener);
+    return () => ipcRenderer.off('native-audio-unavailable', listener);
+  },
+  stopNativeAudio: () => ipcRenderer.send('native-audio-stop'),
+
   selectScreenSource: (sourceId: string | null, shareAudio?: boolean) => {
     ipcRenderer.send('screen-share-selected', sourceId, shareAudio ?? true);
   },

packages/web/src/platform/electron.d.ts

@@ -61,6 +61,11 @@ interface BackspaceElectronAPI {
   // Screen share picker coordination
   onScreenShareSources: (callback: (sources: ElectronScreenSource[]) => void) => void;
   selectScreenSource: (sourceId: string | null, shareAudio?: boolean) => void;
+  onNativeAudioData?: (
+    callback: (data: ArrayBuffer, meta: { sampleRate: number; channels: number; bitsPerSample: number; isFloat: boolean }) => void,
+  ) => () => void;
+  onNativeAudioUnavailable?: (callback: () => void) => () => void;
+  stopNativeAudio?: () => void;
 
   // Instance URL management
   getInstanceUrl: () => Promise<string | null>;

packages/web/src/utils/nativeScreenAudio.ts

@@ -0,0 +1,160 @@
+import { Room, Track, LocalAudioTrack, AudioPresets } from 'livekit-client';
+import { isElectron } from '../platform/platform';
+
+/**
+ * Turns the desktop app's native system-audio capture into a track LiveKit can
+ * publish.
+ *
+ * The native module hands the main process raw PCM, which arrives here in
+ * chunks over IPC. Web Audio has no "push samples" input, so each chunk is
+ * scheduled as a buffer source on a running cursor — the standard way to play a
+ * live stream without gaps.
+ *
+ * Exists because Electron's `audio: 'loopback'` captures the whole output mix,
+ * this app's own playback included, so every listener heard themselves echo.
+ */
+class NativeScreenAudio {
+  private ctx: AudioContext | null = null;
+  private destination: MediaStreamAudioDestinationNode | null = null;
+  private gain: GainNode | null = null;
+  private limiter: DynamicsCompressorNode | null = null;
+  private track: LocalAudioTrack | null = null;
+  private unsubscribe: (() => void) | null = null;
+  private nextStartTime = 0;
+
+  /**
+   * Held ahead of the cursor so a late chunk does not land in the past and get
+   * dropped. Small enough not to be noticeable against the video.
+   */
+  private static readonly BUFFER_AHEAD_S = 0.08;
+  /** Beyond this the stream has stalled; resync rather than drift forever. */
+  private static readonly MAX_DRIFT_S = 0.5;
+
+  /**
+   * WASAPI hands back the process's own mix, which sits far below the level a
+   * microphone track arrives at — listeners had to run the participant at 200%
+   * to hear anything. Boosted here rather than asking every listener to
+   * compensate, with a limiter after it so loud passages do not clip.
+   */
+  private static readonly BOOST = 3.0;
+
+  isActive(): boolean {
+    return this.track !== null;
+  }
+
+  async start(room: Room): Promise<boolean> {
+    if (!isElectron() || !window.backspace?.onNativeAudioData) return false;
+    if (this.track) return true;
+
+    this.ctx = new AudioContext();
+    this.destination = this.ctx.createMediaStreamDestination();
+
+    // source → gain → limiter → destination. The limiter is a compressor with
+    // a high ratio and fast attack: it only engages on peaks the boost would
+    // otherwise clip, and is transparent below that.
+    this.gain = this.ctx.createGain();
+    this.gain.gain.value = NativeScreenAudio.BOOST;
+    this.limiter = this.ctx.createDynamicsCompressor();
+    this.limiter.threshold.value = -6;
+    this.limiter.knee.value = 0;
+    this.limiter.ratio.value = 20;
+    this.limiter.attack.value = 0.003;
+    this.limiter.release.value = 0.1;
+    this.gain.connect(this.limiter);
+    this.limiter.connect(this.destination);
+
+    this.nextStartTime = 0;
+
+    this.unsubscribe = window.backspace.onNativeAudioData((data, meta) => {
+      this.enqueue(data, meta);
+    });
+
+    const mediaTrack = this.destination.stream.getAudioTracks()[0];
+    if (!mediaTrack) {
+      await this.stop();
+      return false;
+    }
+
+    this.track = new LocalAudioTrack(mediaTrack);
+    try {
+      await room.localParticipant.publishTrack(this.track, {
+        source: Track.Source.ScreenShareAudio,
+        // Defaults are tuned for speech: mono, low bitrate, and DTX on, which
+        // stops transmitting during silence. On game and music audio that
+        // reads as clipped and thin.
+        audioPreset: AudioPresets.musicHighQualityStereo,
+        forceStereo: true,
+        dtx: false,
+        red: false,
+      });
+      return true;
+    } catch (err) {
+      console.error('[NativeScreenAudio] publish failed', err);
+      await this.stop();
+      return false;
+    }
+  }
+
+  private enqueue(data: ArrayBuffer, meta: { sampleRate: number; channels: number; isFloat: boolean; bitsPerSample: number }): void {
+    const ctx = this.ctx;
+    const destination = this.destination;
+    if (!ctx || !destination) return;
+
+    // Only float32 is handled: it is what every supported platform reports.
+    // Anything else is dropped rather than played as noise.
+    if (!meta.isFloat || meta.bitsPerSample !== 32) return;
+
+    const samples = new Float32Array(data);
+    const channels = Math.max(1, meta.channels);
+    const frames = Math.floor(samples.length / channels);
+    if (frames === 0) return;
+
+    const buffer = ctx.createBuffer(channels, frames, meta.sampleRate);
+    for (let channel = 0; channel < channels; channel++) {
+      const channelData = buffer.getChannelData(channel);
+      // Interleaved in, planar out. The bounds are computed from the buffer's
+      // own length, but the index signature is still optional under
+      // noUncheckedIndexedAccess — a truncated final chunk reads as silence
+      // rather than NaN, which would click.
+      for (let frame = 0; frame < frames; frame++) {
+        channelData[frame] = samples[frame * channels + channel] ?? 0;
+      }
+    }
+
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    source.connect(this.gain ?? destination);
+
+    const now = ctx.currentTime;
+    if (this.nextStartTime < now || this.nextStartTime > now + NativeScreenAudio.MAX_DRIFT_S) {
+      this.nextStartTime = now + NativeScreenAudio.BUFFER_AHEAD_S;
+    }
+    source.start(this.nextStartTime);
+    this.nextStartTime += buffer.duration;
+  }
+
+  async stop(): Promise<void> {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    window.backspace?.stopNativeAudio?.();
+
+    if (this.track) {
+      try {
+        this.track.stop();
+      } catch { /* already gone */ }
+      this.track = null;
+    }
+    this.gain = null;
+    this.limiter = null;
+    this.destination = null;
+    if (this.ctx) {
+      try {
+        await this.ctx.close();
+      } catch { /* already closed */ }
+      this.ctx = null;
+    }
+    this.nextStartTime = 0;
+  }
+}
+
+export const nativeScreenAudio = new NativeScreenAudio();

packages/web/src/utils/screenShare.ts

@@ -1,5 +1,7 @@
 import { Room, Track, BackupCodecPolicy } from 'livekit-client';
 import { useVoiceStore } from '../stores/voiceStore';
+import { nativeScreenAudio } from './nativeScreenAudio';
+import { isElectron } from '../platform/platform';
 import type { ScreenShareConfig } from '../stores/voiceStore';
 import { getStreamingLimits } from '../stores/settingsStore';
 import { getPublisherPC, getMediaStreamTrack } from './livekitInternals';
@@ -253,7 +255,10 @@ export async function startScreenShare(room: Room): Promise<boolean> {
   try {
     // For native mode: omit resolution constraint to capture at display's full native resolution
     const captureOptions: any = {
-      audio: config.shareAudio ? {
+      // In the desktop app audio never comes through this stream: Electron
+      // ignores these constraints and its loopback would carry our own output
+      // back into the share. The native capture below supplies it instead.
+      audio: config.shareAudio && !isElectron() ? {
         // Chrome 141+: exclude this tab's own audio from system audio capture
         // @ts-ignore — restrictOwnAudio is not yet in all TS type definitions
         restrictOwnAudio: true,
@@ -287,6 +292,14 @@ export async function startScreenShare(room: Room): Promise<boolean> {
       return false;
     }
 
+    // Desktop only, and only after the video track exists: publishing the audio
+    // first would briefly show a share with sound and no picture. A failure
+    // here leaves the share running silently rather than tearing it down.
+    if (isElectron() && config.shareAudio) {
+      const ok = await nativeScreenAudio.start(room);
+      if (!ok) console.warn('[SS] native system audio unavailable — sharing without sound');
+    }
+
     // Set content hint from builder (motion for gaming, detail for text)
     const screenPub = room.localParticipant.getTrackPublications()
       .find(p => p.source === Track.Source.ScreenShare);
@@ -416,6 +429,9 @@ function scheduleEncoderDetection(room: Room): void {
 // ---------------------------------------------------------------------------
 
 export async function stopScreenShare(room: Room): Promise<void> {
+  // Stopped first: leaving the native capture running would keep reading system
+  // audio after the share is gone.
+  await nativeScreenAudio.stop();
   try {
     await room.localParticipant.setScreenShareEnabled(false);
   } catch (err) {

pnpm-lock.yaml

@@ -25,6 +25,9 @@ importers:
 
   packages/desktop:
     dependencies:
+      electron-native-screenshare:
+        specifier: ^1.2.0
+        version: 1.2.0
       electron-updater:
         specifier: ^6.3.0
         version: 6.8.3
@@ -876,11 +879,11 @@ packages:
 
   '@esbuild-kit/core-utils@3.3.2':
     resolution: {integrity: sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ==}
-    deprecated: 'Merged into tsx: https://tsx.is'
+    deprecated: 'Merged into tsx: https://tsx.hirok.io'
 
   '@esbuild-kit/esm-loader@2.6.5':
     resolution: {integrity: sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA==}
-    deprecated: 'Merged into tsx: https://tsx.is'
+    deprecated: 'Merged into tsx: https://tsx.hirok.io'
 
   '@esbuild/aix-ppc64@0.19.12':
     resolution: {integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==}
@@ -2119,6 +2122,7 @@ packages:
 
   '@ungap/structured-clone@1.3.0':
     resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
+    deprecated: Potential CWE-502 - Update to 1.3.1 or higher
 
   '@vitejs/plugin-react@4.7.0':
     resolution: {integrity: sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==}
@@ -2158,6 +2162,7 @@ packages:
   '@xmldom/xmldom@0.8.11':
     resolution: {integrity: sha512-cQzWCtO6C8TQiYl1ruKNn2U6Ao4o4WBBcbL61yJl84x+j5sOWWFU9X7DpND8XZG3daDppSsigMdfAIl2upQBRw==}
     engines: {node: '>=10.0.0'}
+    deprecated: this version has critical issues, please update to the latest version
 
   abbrev@1.1.1:
     resolution: {integrity: sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==}
@@ -2953,6 +2958,11 @@ packages:
     engines: {node: '>=14.0.0'}
     hasBin: true
 
+  electron-native-screenshare@1.2.0:
+    resolution: {integrity: sha512-O7m+/AeE0UWFq8Z18THGSrPHRIxYiYtjdMKtVhGcNRE/sUN6Fj9EgXDOmmJnORCh303NWaNgmAnNz+JbeLa48Q==}
+    engines: {node: '>=18.0.0'}
+    os: [win32, linux, darwin]
+
   electron-publish@25.1.7:
     resolution: {integrity: sha512-+jbTkR9m39eDBMP4gfbqglDd6UvBC7RLh5Y0MhFSsc6UkGHj9Vj9TWobxevHYMMqmoujL11ZLjfPpMX+Pt6YEg==}
 
@@ -4184,6 +4194,9 @@ packages:
   node-addon-api@1.7.2:
     resolution: {integrity: sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg==}
 
+  node-addon-api@7.1.1:
+    resolution: {integrity: sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==}
+
   node-api-version@0.2.1:
     resolution: {integrity: sha512-2xP/IGGMmmSQpI1+O/k72jF/ykvZ89JeuKX3TLJAYPDVLUalrshrLHkeVcCCZqG/eEa635cr8IBYzgnDvM2O8Q==}
 
@@ -8257,6 +8270,10 @@ snapshots:
       - electron-builder-squirrel-windows
       - supports-color
 
+  electron-native-screenshare@1.2.0:
+    dependencies:
+      node-addon-api: 7.1.1
+
   electron-publish@25.1.7:
     dependencies:
       '@types/fs-extra': 9.0.13
@@ -9929,6 +9946,8 @@ snapshots:
   node-addon-api@1.7.2:
     optional: true
 
+  node-addon-api@7.1.1: {}
+
   node-api-version@0.2.1:
     dependencies:
       semver: 7.7.4

tools/sfx/README.md

@@ -0,0 +1,32 @@
+# Geradores dos efeitos sonoros
+
+Os `.ogg` em `packages/web/public/sounds/` para call e transmissão são
+sintetizados por estes scripts — nenhum arquivo de terceiros, nenhuma questão
+de licença num repositório público.
+
+Os parâmetros não foram escolhidos a gosto: saíram da **medição** de dois sons
+de referência fornecidos pelo dono da instância (análise de envelope, picos
+espectrais e tempo de decaimento). O timbre resultante é fundamental + oitava
+quase na mesma intensidade, com pouco acima disso:
+
+| Harmônico | Proporção medida |
+|---|---|
+| 1x (fundamental) | 1.00 |
+| 2x (oitava)      | 0.85 |
+| 3x               | 0.10 |
+| 4x               | 0.02 |
+
+Decaimento a 1/e: ~0,19 s. Sem reverberação.
+
+| Script | Gera | Notas |
+|---|---|---|
+| `build.py`    | `user_join`, `user_leave` | C4→G4 subindo / D4→G3 descendo |
+| `stream.py`   | `stream_user_joined`, `stream_user_left` | nota única (G4 / G3), ~55% do volume |
+| `started4.py` | `stream_started` | acorde de dó + golpe grave + sopro de ar |
+| `ended.py`    | `stream_ended` | arpejo descendo, resolve na raiz grave |
+
+Para regerar: `python3 <script>.py` produz `.wav`, depois converter com
+`ffmpeg -i X.wav -c:a libvorbis -q:a 5 -ar 48000 X.ogg`.
+
+Ajustes comuns: `HARM` muda o timbre, `tau` a duração, `step` a velocidade do
+arpejo, e o alvo em `write()` o volume (pico RMS).

tools/sfx/build.py

@@ -0,0 +1,47 @@
+import math, wave, struct
+SR=48000
+# Proporcoes medidas nas referencias: fundamental, oitava, 3o, 4o
+HARM=(1.00, 0.85, 0.10, 0.02)
+TAU=0.19          # decaimento a 1/e medido
+ATTACK=0.004
+
+def note(f, dur):
+    n=int(SR*dur); o=[]
+    for i in range(n):
+        t=i/SR
+        s=sum(a*math.sin(2*math.pi*f*(k+1)*t) for k,a in enumerate(HARM))
+        o.append(s*min(1.0,t/ATTACK)*math.exp(-t/TAU))
+    return o
+
+def mix(layers,total):
+    b=[0.0]*total
+    for off,s in layers:
+        for i,v in enumerate(s):
+            if off+i<total: b[off+i]+=v
+    return b
+
+def peak_rms(x, win=int(SR*0.01)):
+    best=0.0
+    for i in range(0,len(x)-win,win):
+        seg=x[i:i+win]
+        best=max(best, math.sqrt(sum(v*v for v in seg)/len(seg)))
+    return best
+
+def write(name, buf, target_rms):
+    cur=peak_rms(buf)
+    g=target_rms/max(1e-9,cur)
+    # nao deixa estourar mesmo casando o volume da referencia
+    pk=max(abs(s*g) for s in buf)
+    if pk>0.97: g*=0.97/pk
+    with wave.open(name,'w') as w:
+        w.setnchannels(1); w.setsampwidth(2); w.setframerate(SR)
+        w.writeframes(b''.join(struct.pack('<h',int(max(-1,min(1,s*g))*32767)) for s in buf))
+    print(f"{name}: pico RMS {peak_rms([s*g for s in buf]):.3f}, {len(buf)/SR:.2f}s")
+
+C4,D4,G3,G4 = 261.63, 293.66, 196.00, 392.00
+GAP=int(SR*0.10)   # 100ms entre as notas, medido
+
+# join: quinta subindo — mesmas notas da referencia
+write('user_join.wav',  mix([(0,note(C4,0.55)),(GAP,note(G4,0.55))], int(SR*0.62)), 0.365)
+# leave: quinta descendo
+write('user_leave.wav', mix([(0,note(D4,0.55)),(GAP,note(G3,0.55))], int(SR*0.62)), 0.440)

tools/sfx/ended.py

@@ -0,0 +1,53 @@
+import math, wave, struct
+SR=48000
+HARM=(1.00, 0.85, 0.10, 0.02)
+
+def note(f, dur, tau, amp=1.0):
+    n=int(SR*dur); o=[]
+    for i in range(n):
+        t=i/SR
+        s=sum(a*math.sin(2*math.pi*f*(k+1)*t) for k,a in enumerate(HARM))
+        o.append(s*amp*min(1.0,t/0.004)*math.exp(-t/tau))
+    return o
+
+def thump(f, dur, amp):
+    n=int(SR*dur); o=[]; ph=0.0
+    for i in range(n):
+        t=i/SR
+        ph += 2*math.pi*(f*(1+1.2*math.exp(-t/0.02)))/SR
+        o.append(math.sin(ph)*amp*math.exp(-t/(dur*0.30)))
+    return o
+
+def mix(layers,total):
+    b=[0.0]*total
+    for off,s in layers:
+        for i,v in enumerate(s):
+            if off+i<total: b[off+i]+=v
+    return b
+
+def peak_rms(x, win=int(SR*0.01)):
+    return max(math.sqrt(sum(v*v for v in x[i:i+win])/win) for i in range(0,len(x)-win,win))
+
+def write(name, buf, target):
+    g=target/max(1e-9,peak_rms(buf))
+    pk=max(abs(s*g) for s in buf)
+    if pk>0.97: g*=0.97/pk
+    with wave.open(name,'w') as w:
+        w.setnchannels(1); w.setsampwidth(2); w.setframerate(SR)
+        w.writeframes(b''.join(struct.pack('<h',int(max(-1,min(1,s*g))*32767)) for s in buf))
+    print(f"{name}: pico RMS {peak_rms([s*g for s in buf]):.3f}, {len(buf)/SR:.2f}s")
+
+C3,C4,E4,G4,C5 = 130.81,261.63,329.63,392.00,523.25
+step=int(SR*0.033)
+
+# Espelho do inicio: o arpejo DESCE e resolve na raiz grave, que entra por
+# ultimo. Sem o sopro de ar — brilho sugere chegada, nao encerramento.
+# Mais curto e mais baixo: encerrar merece menos destaque que comecar.
+write('stream_ended.wav', mix([
+    (0,      note(C5, 0.42, 0.15, 0.70)),
+    (step,   note(G4, 0.44, 0.16)),
+    (2*step, note(E4, 0.46, 0.17)),
+    (3*step, note(C4, 0.48, 0.19)),
+    (3*step, note(C3, 0.50, 0.21, 0.80)),
+    (3*step, thump(85, 0.13, 0.40)),
+], int(SR*0.55)), 0.34)

tools/sfx/started4.py

@@ -0,0 +1,65 @@
+import math, random, wave, struct
+SR=48000; random.seed(11)
+HARM=(1.00, 0.85, 0.10, 0.02)
+
+def note(f, dur, tau, amp=1.0):
+    n=int(SR*dur); o=[]
+    for i in range(n):
+        t=i/SR
+        s=sum(a*math.sin(2*math.pi*f*(k+1)*t) for k,a in enumerate(HARM))
+        o.append(s*amp*min(1.0,t/0.004)*math.exp(-t/tau))
+    return o
+
+def thump(f, dur, amp):
+    """Instrumento 2: golpe grave com queda de tom. Da impacto no ataque e
+    morre em 90ms — engorda sem alongar."""
+    n=int(SR*dur); o=[]; ph=0.0
+    for i in range(n):
+        t=i/SR
+        ph += 2*math.pi*(f*(1+1.2*math.exp(-t/0.02)))/SR
+        o.append(math.sin(ph)*amp*math.exp(-t/(dur*0.30)))
+    return o
+
+def air(dur, amp, cutoff=5000):
+    """Instrumento 3: sopro curto de ruido filtrado. Brilho no inicio, sem cauda."""
+    n=int(SR*dur)
+    y=0.0; a=1-math.exp(-2*math.pi*cutoff/SR); o=[]
+    for i in range(n):
+        t=i/SR
+        y += a*(random.uniform(-1,1)-y)
+        o.append(y*amp*min(1.0,t/0.008)*math.exp(-t/(dur*0.22)))
+    return o
+
+def mix(layers,total):
+    b=[0.0]*total
+    for off,s in layers:
+        for i,v in enumerate(s):
+            if off+i<total: b[off+i]+=v
+    return b
+
+def peak_rms(x, win=int(SR*0.01)):
+    return max(math.sqrt(sum(v*v for v in x[i:i+win])/win) for i in range(0,len(x)-win,win))
+
+def write(name, buf, target):
+    g=target/max(1e-9,peak_rms(buf))
+    pk=max(abs(s*g) for s in buf)
+    if pk>0.97: g*=0.97/pk
+    with wave.open(name,'w') as w:
+        w.setnchannels(1); w.setsampwidth(2); w.setframerate(SR)
+        w.writeframes(b''.join(struct.pack('<h',int(max(-1,min(1,s*g))*32767)) for s in buf))
+    print(f"{name}: pico RMS {peak_rms([s*g for s in buf]):.3f}, {len(buf)/SR:.2f}s")
+
+C3,G3,C4,E4,G4,C5 = 130.81,196.00,261.63,329.63,392.00,523.25
+step=int(SR*0.033)   # arpejo bem rapido: acorde montado em 100ms
+
+# Decaimentos ~metade dos anteriores (0.20 vs 0.38). Total 0.62s vs 1.08s.
+write('stream_started.wav', mix([
+    (0,      thump(85, 0.14, 0.55)),        # impacto
+    (0,      air(0.13, 0.16)),              # brilho
+    (0,      note(C3, 0.60, 0.22, 0.80)),
+    (0,      note(G3, 0.58, 0.20, 0.45)),
+    (0,      note(C4, 0.56, 0.20)),
+    (step,   note(E4, 0.54, 0.19)),
+    (2*step, note(G4, 0.52, 0.18)),
+    (3*step, note(C5, 0.50, 0.16, 0.70)),
+], int(SR*0.62)), 0.42)

tools/sfx/stream.py

@@ -0,0 +1,31 @@
+import math, wave, struct
+SR=48000
+HARM=(1.00, 0.85, 0.10, 0.02)   # mesmo timbre medido nas referencias
+ATTACK=0.004
+
+def note(f, dur, tau):
+    n=int(SR*dur); o=[]
+    for i in range(n):
+        t=i/SR
+        s=sum(a*math.sin(2*math.pi*f*(k+1)*t) for k,a in enumerate(HARM))
+        o.append(s*min(1.0,t/ATTACK)*math.exp(-t/tau))
+    return o
+
+def peak_rms(x, win=int(SR*0.01)):
+    return max(math.sqrt(sum(v*v for v in x[i:i+win])/win)
+               for i in range(0,len(x)-win,win))
+
+def write(name, buf, target):
+    g=target/max(1e-9,peak_rms(buf))
+    pk=max(abs(s*g) for s in buf)
+    if pk>0.97: g*=0.97/pk
+    with wave.open(name,'w') as w:
+        w.setnchannels(1); w.setsampwidth(2); w.setframerate(SR)
+        w.writeframes(b''.join(struct.pack('<h',int(max(-1,min(1,s*g))*32767)) for s in buf))
+    print(f"{name}: pico RMS {peak_rms([s*g for s in buf]):.3f}, {len(buf)/SR:.2f}s")
+
+G3, G4 = 196.00, 392.00
+# Decaimento mais curto (0.13 vs 0.19) e volume ~55% do som de call:
+# entrar/sair da tela dispara muitas vezes durante uma transmissao.
+write('stream_user_joined.wav', note(G4, 0.42, 0.13), 0.20)
+write('stream_user_left.wav',   note(G3, 0.42, 0.13), 0.20)