mirror of https://github.com/J3vb/OwnCord.git synced 2026-09-03 03:50:00 +03:00

Files

T

J3vbandClaude Opus 5 2a37f386f9 B1-3: repository hygiene gates (RL-19 / L-13, S-05) (#1414 )

* chore(format): one Prettier config at the repository root

Every formatting rule in this repository lived under Client/ and covered
exactly two globs: Client/src/**/*.ts and Client/tests/**/*.ts. Root Markdown,
all of docs/, every YAML and JSON, all CSS, the root scripts and
tools/mcp-introspect were formatted by nothing. There was no .editorconfig.

The obvious fix -- a second Prettier config at the root for "everything else"
-- gives two configs and two ignore files that can silently disagree about the
same file. So the root takes ownership instead: config, ignore file and gate
move up, and Client/ folds in. Client's inline "prettier" block, its
.prettierignore, its format/format:check scripts and its now-unused prettier
devDependency are all deleted; knip would have failed client-check on that last
one.

The .prettierrc.json values are lifted byte-for-byte from Client/package.json,
which is what keeps the reformat commit free of client TypeScript churn: 87
tracked files need reformatting and not one of them is under Client/src or
Client/tests.

.prettierignore carries only what .gitignore does not. Prettier 3 reads the
root .gitignore by default, so node_modules/, dist/, coverage/,
Client/src/generated/ and docs/security-findings/ need no entry. It does NOT
read nested .gitignore files, which is why .remember/ is listed explicitly --
38 untracked per-machine scratch files were otherwise able to turn a shared
gate red. graphify-out/ is listed because its seven files are tracked and
.graphify_labels.json is signed byte-for-byte by its .sig, so formatting it
would silently invalidate the signature.

check:hygiene is registered in scripts/run.mjs and folded into check and
release:preflight. It deliberately contains no `gofmt -l` step: gofmt -l prints
offenders and still exits 0, so it cannot fail a build. Go formatting is
enforced separately.

shellcheck and actionlint take their file lists from `git ls-files`, never a
filesystem glob -- .claude/worktrees/ holds a gitignored pre-flatten copy of
the tree with three .sh files a glob would happily lint.

This commit leaves the tree non-conformant on purpose. The reformat is the next
commit, so the 87-file diff is reviewable separately from the rule that caused
it.

Not included: editorconfig-checker. .editorconfig is the editor baseline the
audit asked for; Prettier, gofmt and rustfmt already fail CI on the same
indentation and newline rules, so a fourth tool checking them again is a gate
with no failure mode of its own.

Verified: `npx prettier --check .` names 87 tracked files and zero untracked
ones; the same command listed 38 .remember/ scratch files before the ignore
entry and none after. `node scripts/run.mjs --list` resolves check:hygiene to 8
shell targets and 4 workflow targets. Both package.json files parse.

Refs RL-19 / L-13, S-05.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* chore(format): reformat the tree to the repository Prettier rules

Mechanical. This commit is `npx prettier --write .` and nothing else -- the
rule that caused it landed in the previous commit so this diff can be reviewed
as a transformation rather than as 84 files of hunks.

84 tracked files: 54 Markdown, 7 .mjs, 7 JSON, 6 YAML, 4 .js, 3 CSS, 2
TypeScript (the two Playwright configs at Client's root, which the old
Client/src + Client/tests globs never covered). No file under Client/src or
Client/tests moves, because .prettierrc.json carries Client's former inline
values byte-for-byte.

Prettier rewrote 87 files, not 84. The three in .github/ISSUE_TEMPLATE/ had
CRLF on disk and differ only in line endings, which .gitattributes
(`* text=auto eol=lf`) already normalises, so their committed blobs are
unchanged. Worth knowing before someone reconciles the two numbers.

The largest single diff is .superpowers/findings-ledger.json at 7976 lines
rewritten. That is safe to format: nothing writes the ledger programmatically
-- render-ledger.mjs reads it and writes only FINDINGS.md -- so no tool will
fight Prettier over its style on the next hunt. FINDINGS.md itself is ignored
as generated.

Verified: `npx prettier --check .` reports "All matched files use Prettier code
style", so the pass is both complete and idempotent. All 7 reformatted JSON
files were parsed before and after and compared as values: semantically
identical, zero content changes. `node .superpowers/render-ledger.mjs --check`
still reports 348 valid findings and leaves FINDINGS.md untouched.
`node scripts/check-doc-counts.mjs` still passes its selftest and still agrees
on 27 claims across 9 watched documents -- table realignment did not break the
patterns it matches on. `node scripts/run.mjs --list` still parses.

Refs RL-19 / L-13, S-05.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* chore(lint): enforce Go formatting in the Server linter

S-05: repository-wide Go formatting was not a required gate. The only gofmt
enforcement anywhere was .githooks/pre-commit, which is opt-in per clone
(`npm run hooks:install`), only sees staged files, and warns-and-skips when
gofmt is off PATH.

The obvious fix -- a `gofmt -l` step in CI -- does not work: `gofmt -l` prints
its offenders and still exits 0, so the step passes no matter what it finds.
scripts/run.mjs has the same problem, which is why check:hygiene has no Go step
either.

So gofmt goes where it can actually fail something: Server/.golangci.yml. The
file was already `version: "2"` but had no `formatters:` block at all, so the
19 enabled linters ran with zero formatters. In v2 gofmt/gofumpt/goimports
moved out of `linters.enable` into their own section with its own exclusions.
Adding it there means the gate reports through the Lint step of "Server Build &
Test", which is already pinned as required on dev -- no new job and no new pin.
Every tracked .go file is under Server/ (551 of them, one go.mod), so
Server-scoped is repository-wide here.

One file was genuinely misformatted: a one-space struct field alignment in
Server/admin/handlers_users_broadcast_test.go, fixed in the same commit because
a single line does not need its own reformat commit.

Trap worth recording: `gofmt -l .` on a Windows working tree lists every file
that has CRLF on disk, because gofmt normalises line endings. That reported 18
offenders here, 17 of them ghosts. The blobs are all LF -- .gitattributes
forces `eol=lf` -- so CI never saw them, and the honest test is to run gofmt
over `git show HEAD:<file>` rather than the working copy. Doing that across all
551 tracked Go files found exactly the one real offender above.

Verified both directions with golangci-lint v2 locally: `golangci-lint run
./...` reports 0 issues on the formatted tree; appending a misformatted
function to Server/auth/constants.go produces 2 gofmt findings; appending the
same misformatted function to Server/db/dbgen/admin.sql.go produces 0, so the
exclusion holds. Both files restored and verified clean afterwards.

Refs RL-19 / L-13, S-05.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(scripts): escape the NUL separator instead of embedding one

The `tracked()` helper added earlier in this branch splits `git ls-files -z`
output on NUL. The separator was written as a literal NUL byte rather than the
two-character JavaScript escape, so scripts/run.mjs became a binary file: `git
diff` refused to show it, `grep` reported "Binary file matches" instead of the
line, and `* text=auto` in .gitattributes stops normalising line endings for a
blob it detects as binary.

The code worked -- splitting on a raw NUL and splitting on "\0" are the same
operation -- which is exactly why this is worth fixing before it is inherited.
A source file that tooling classifies as binary is a file nobody can review.

Verified: zero NUL bytes remain, `grep -n "split("` now prints line 50 instead
of "Binary file matches", `node scripts/run.mjs --list` still resolves the same
8 shell and 4 workflow targets, and prettier still reports the file clean.

* chore(lint): enforce Rust formatting

Rust had no formatting gate of any kind: no rustfmt.toml, no `cargo fmt`
anywhere in CI, in scripts/run.mjs, in the Makefile or in the git hooks. Clippy
was the only Rust gate, and clippy does not check layout.

`cargo fmt --all -- --check` now runs in the rust-tests job, ahead of clippy: a
formatting failure is cheap to produce and cheap to fix, and there is no reason
to spend a clippy pass to surface one. The stable toolchain in that job
requested `components: clippy` only, so rustfmt is added there.

Only that job. ci.yml has a second, byte-identical `Install Rust` block in
tauri-build; it stays clippy-only, because a full desktop build is the wrong
place to discover a misplaced brace.

No rustfmt.toml. The default profile is the point of a baseline -- a config
file here would be a second opinion about style with nothing to say.
Client/src-tauri is a single `[package]`, not a workspace, so `--all` is a
safeguard against a future member rather than a fan-out today.

Verified: `node scripts/run.mjs --list` resolves check:rust to three steps with
`cargo fmt --all -- --check` first, `npm run format` now also runs `cargo fmt
--all`, and prettier reports ci.yml, run.mjs and the ci-check skill clean.
`cargo fmt --all -- --check` currently fails on 13 files -- that is the
reformat, and it is the next commit.

Refs RL-19 / L-13.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* chore(format): reformat the Rust crate to rustfmt defaults

Mechanical. This commit is `cargo fmt --all` and nothing else; the gate that
demands it landed in the previous commit so this diff is reviewable on its own.

13 of the 17 tracked .rs files, +343/-164. The crate had never been formatted,
so the changes are the usual first-run set: aligned trailing comments collapsed
to single spaces, single-element slice literals folded onto one line, long
method chains broken across lines, closure bodies expanded into blocks.

Verified: `cargo fmt --all -- --check` is clean, so the pass is complete and
idempotent. `cargo clippy --all-targets -- -D warnings` finishes with no
warnings, and `cargo test --lib` reports 115 passed / 0 failed -- identical to
before the reformat, which is what "mechanical" has to mean for a commit that
touches this much of the crate.

Refs RL-19 / L-13.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(scripts): make the root facade actually run on Windows

Adding the first gate that a contributor would run from the repository root
exposed two bugs in the facade, both of which made it silently wrong on the
platform this project is developed on.

1. Every npm and npx step failed. bin() appends `.cmd` on Windows, but Node
   refuses to spawn a .cmd or .bat with shell:false -- the CVE-2024-27980
   mitigation -- and fails with EINVAL and a *null* exit status. run.mjs only
   special-cased ENOENT, so the result was `FAILED: npx prettier --check .
   exited null` with nothing to explain it. check:client has three npm steps and
   has never been able to run here.

   Fixed by spawning only the npm shims through a shell. They are concatenated
   into a single command string rather than passed as an args array, because
   shell:true plus a separate array is deprecated (DEP0190) and prints a warning
   on every invocation; no argument in this file contains a space.

2. Every optional() step was skipped, always. onPath() shelled out to
   `where` on Windows, but where.exe lives in C:\WINDOWS\System32, which a Git
   Bash PATH does not necessarily contain -- on this machine PATH carries
   System32\Wbem, System32\WindowsPowerShell\v1.0 and System32\OpenSSH but not
   System32 itself. The probe could not start, `probe.status === 0` was false,
   and golangci-lint and sqlc reported as "not installed" while installed.

   Fixed by resolving against PATH and PATHEXT directly. No subprocess, and no
   dependency on which directories happen to be on PATH.

A spawn error other than ENOENT now reports its code instead of surfacing as a
null exit status.

Verified: before, `node scripts/run.mjs check:hygiene` died with "exited null"
and both optional steps printed SKIP with the tools present on PATH. After, the
same command runs prettier, shellcheck and actionlint and prints
"check:hygiene: passed", with no deprecation warning. `golangci-lint` is
detected by the new onPath where the old one missed it.

Refs RL-20 / L-14.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* chore(format): ignore build output that nested gitignores hide

Prettier honours the root .gitignore and no other. Every build and scratch
directory in this repository is ignored by a *nested* one -- Client/.gitignore,
.serena/.gitignore, .superpowers/sdd/.gitignore -- so none of them were
excluded from the new repository-wide gate.

The effect is not subtle. Running `cargo test` once drops roughly 850
formattable files into Client/src-tauri/target/, and the hygiene gate goes from
clean to "Code style issues found in 939 files". CI never sees it, because a
fresh checkout has no build output; every contributor sees it on their second
command.

Mirrors the three nested files rather than inventing a list: dist, coverage,
playwright-report, test-results, .vite, src-tauri/target and src-tauri/gen from
Client/.gitignore, plus .serena/ and .superpowers/sdd/. node_modules needs no
entry -- Prettier ignores it by default.

Verified: `npx prettier --check .` reports "All matched files use Prettier code
style" with a fully populated Client/src-tauri/target/ present on disk, and
still names README.md when a misformatted table is appended to it.

Refs RL-19 / L-13.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* chore(ci): shellcheck, actionlint, and a repository hygiene job

The last two gates RL-19 asks for. Neither existed: the shell scripts were
never linted, the workflows were never syntax-checked, and .githooks/pre-commit
carried hand-written `# shellcheck disable=` directives that nothing had ever
read.

New `hygiene` job, ubuntu-only and root-scoped, modelled on docs-consistency
for the same reason: every gate in it is platform-independent text analysis,
and .gitattributes pins eol=lf so a second OS would only re-prove line endings.
It runs `npm run check:hygiene` -- the same entry point a contributor runs, not
a parallel copy of the commands.

shellcheck ships in the runner image. actionlint does not, so it is pinned by
version and verified by sha256: an installer script piped from a branch would
be the one unverified download in a workflow file that pins every action by
commit SHA.

Prettier's step moves here from client-check, where it no longer belongs.

Both linters found real defects.

shellcheck, 3 findings in 8 scripts. Two are SC1125 errors in
.githooks/pre-commit: `# shellcheck disable=SC2086 - repo paths contain no
spaces` is not a valid directive. Trailing prose makes shellcheck discard the
rest of the line, so neither suppression was ever in effect -- and one of the
two was written earlier in this same branch, which is a fair demonstration of
why the gate is worth having. The prose moves to its own line above. The third
is SC2015 in start-server.sh, rewritten as an explicit if.

actionlint, 5 findings, all inside `run:` blocks it shellchecks once shellcheck
is on PATH. Three SC2015 in load-baseline.yml, rewritten as explicit ifs. Two
SC2035 in release.yml, where `sha256sum *` should not become `sha256sum ./*`:
the comment four lines above records that ParseChecksumFile exact-matches the
last field, so a "./" prefix would strand every deployed server exactly as a
"windows/" prefix would. `sha256sum -- *` satisfies the linter and leaves the
output bytes identical.

Verified all three gates in both directions with shellcheck 0.10.0 and
actionlint 1.7.7 on PATH. Passing: `node scripts/run.mjs check:hygiene` prints
"check:hygiene: passed" with all three steps run, not skipped. Failing:
appending `bait_fn() { cat $1; }` to Server/scripts/voice-test.sh fails on
SC2086; changing a runs-on to `ubunt-latest` fails on runner-label; appending a
misformatted table to README.md fails prettier. All three files restored and
confirmed clean afterwards. actionlint validates the new job in ci.yml itself.

Refs RL-19 / L-13, S-05.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* docs(plans): record B1 progress through B1-3

The header still read "B1-0 is complete; B1-1 is the next step" three merged
phases later. A plan that misstates where it is costs a reader the same
confusion whether it is stale by one phase or three.

B1-0 (#1410), B1-1 (#1411), B1-2 (#1412) and B1-3 (this branch) are done; B1-4,
dependency automation, is next.

Verified: `node scripts/check-doc-counts.mjs` still agrees on 27 claims across
9 watched documents -- this file is one of them -- and prettier reports it
clean.

* chore(ci): pin Repository Hygiene as a required check on dev

The second half of S-05. Its acceptance criterion is "tree is formatted AND a
fast required gate fails future drift" -- a check that runs but is not pinned
lets a formatting regression merge, so the gate is not a gate until this lands.

The name was read off PR #1414 with `gh pr checks` after the job reported
`pass` in 26s, not copied out of ci.yml. That order matters: the B0 script
records that three pinned names exist in no workflow file at all, and that a
required check which never reports blocks every PR forever.

Extends the existing script rather than adding a second one, per the B1 plan.

Also records, in the "deliberately NOT pinned" list, that Docs & Ledger
Consistency reports and passes on a dev PR yet is unpinned. That reads as an
oversight from the 2026-08-25 pass rather than a decision, but it belongs to
G-04, so it is documented here and not changed.

NOT APPLIED YET. Running this script now would pin a check that PR #1413 cannot
report -- its branch predates the hygiene job, so the job does not exist in its
workflow file and the check would never arrive. Run it after #1414 merges;
#1413 needs a rebase onto dev regardless.

Verified: shellcheck clean, the embedded JSON parses, and `check:hygiene`
passes with prettier, shellcheck and actionlint all running.

Refs S-05, RL-14 / G-03.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

2026-08-26 18:00:26 +00:00

16 KiB

Raw Blame History

Voice, Video & E2EE — target UX

Verified against: commit 5630aa1, 2026-08-04 Part of the Client UX Specification. The signaling/crypto mechanics are mapped structurally in ../voice-e2ee.md; this document specifies the user-facing states and reactions.

Covers: joining/leaving voice, mute/deafen/camera/screenshare, push-to-talk, the active-speaker display, and — the main gap — the E2EE "securing / secured" indicators.

1. Two state machines, one status

Internally there are two FSMs:

The WS connection FSM (ws.ts: disconnected…connected) — the socket.
The voice session FSM (livekitSession.ts: idle | connecting | connected | reconnecting) — the LiveKit room.

Plus the user-facing booleans in voice.store (localMuted, localDeafened, localCamera, localScreenshare, listenOnly, joinedAt) and the per-user roster (voiceUsers with per-user speaking/muted/deafened/camera/screenshare).

Target: expose the voice session as one observable voiceStatus the widgets read — idle | joining | securing | connected | reconnecting — rather than inferring it from isVoiceConnected() alone.

✓ Implemented (2026-07). voice.store.voiceStatus (idle | joining | securing | connected | reconnecting) is now the observable voice-session status. livekitSession.ts is the single writer: joining at the start of connectAndSetup, securing when the ECDH key exchange begins, connected on the atomic connected transition (both the initial join and a successful auto-reconnect), reconnecting when the room drops and the reconnect loop forms its state, and idle on leaveVoice. joinVoiceChannel seeds joining optimistically on click so the widget reacts before the voice_token round-trip. The VoiceWidget reads it to distinguish "connecting to the room" from "securing the encryption" from "reconnecting". failed is not a persisted status: an E2EE-timeout / connection error auto-leaves to idle and surfaces a toast via onErrorCallback (§2).

2. Join / leave

stateDiagram-v2
    idle --> joining: click voice channel → voice_join → voice_token
    joining --> securing: room.connect ok, E2EE key exchange begins
    securing --> connected: room key ready (holder generates / member receives)
    securing --> failed: e2ee_timeout (no key within ~15s)
    joining --> reconnecting: transient connect failure (retry ≤3)
    connected --> reconnecting: socket/room drop
    reconnecting --> connected: re-announce key + rejoin (≤2 attempts)
    reconnecting --> failed: attempts exhausted
    connected --> idle: leave
    failed --> idle: auto-leave + error

Status	Presentation	Notes
`joining`	Voice widget shows "Connecting…"; channel roster shows self pending	`handleVoiceToken` → `connectAndSetup`
`securing`	"Securing connection…" indicator (lock, in-progress)	Non-key-holders block here until a room key arrives (10 s + 5 s retry, the "securing" key-exchange block in `connectAndSetup` (`lib/livekitSession.ts`) / `E2EEManager.setupKeyExchange` (`lib/livekitE2EE.ts`))
`connected`	"Voice connected · secured 🔒" + elapsed timer (from `joinedAt`)	E2EE active; per-user tiles live
`reconnecting`	"Reconnecting voice…"; controls frozen, not torn down	Keypair regenerated for forward secrecy (`attemptAutoReconnect()` → `reannounceForReconnect()`, `lib/livekitSession.ts`)
`failed`	Toast "Voice connection lost" / "Couldn't secure the call"; auto-leave	`onErrorCallback` fires

Target rules:

The "connecting" vs "securing" distinction is user-visible: while a non-key-holder waits for the room key, show securing, not a generic spinner — an E2EE call that's still exchanging keys is not yet private.
Leaving is immediate and local (leaveVoice): tear down tracks, clear E2EE state, reset camera/screenshare, idle.

✓ Implemented (2026-07). The VoiceWidget header now renders the E2EE phase from voiceStatus: a "Securing…" label (amber) while the key exchange runs and a persistent "🔒 Secured" badge once the room key is ready and the room is connected — replacing the log-line-only feedback. joining shows "Connecting…" and reconnecting shows "Reconnecting voice…", neither showing the secured badge. An E2EE-timeout still surfaces its "e2ee_timeout" toast and auto-leaves (livekitSession.ts connectAndSetup). Code vs. diagram note: the client actually runs the ECDH key exchange before room.connect(), so securing spans the key wait and the media connect; the state diagram below draws them in the reverse order for readability. The distinction users see is unchanged: non-key-holders sit in securing until a room key arrives.

3. Local controls

All four are optimistic with rollback; each also emits a WS control message.

Control	Local state	WS message	Rollback
Mute	`localMuted` (`setLocalMuted`) — fully unpublishes the mic track	`voice_mute{muted}`	n/a (local-authoritative)
Deafen	`localDeafened` + forces mute — unsubscribes remote voice audio only; screen-share/stream audio keeps playing (it has its own per-tile mute/volume)	`voice_deafen` + `voice_mute`	implies mute
Camera	`localCamera` set optimistically, rolled back on device failure (`enableCamera()` in `lib/screenShare.ts`)	`voice_camera{enabled}`	revert on failure + toast
Screenshare	`localScreenshare` optimistic, rollback on failure (`enableScreenshare()` in `lib/screenShare.ts`); rate-limited	`voice_screenshare{enabled}`	revert + toast

Control state	Presentation
mic muted	Mic-slash icon on self tile + control bar
deafened	Headphone-slash; implies muted styling
listen-only	Badge "Listen only — no microphone" with a Retry mic affordance (`retryMicPermission`)
camera on	Self video tile in the grid
screenshare on	Screen tile; a stop-share affordance always visible
speaking	Green ring on the speaking user's tile/avatar (from `voice_speakers` / ActiveSpeakers)

Mic-permission failure (restoreLocalVoiceState): on denied/absent mic, set listenOnly and surface the specific reason ("Microphone permission denied" / "No microphone found") as a toast with a retry — already wired to onErrorCallback (the mic-unavailable branches of restoreLocalVoiceState(), lib/livekitSession.ts); the spec makes the Retry mic control a permanent part of the listen-only badge.

4. Push-to-talk

PTT is a Rust key-poller (ptt.rs, 20 ms) emitting ptt-state{pressed} → setMuted(!pressed) only while in a channel (the ptt-state listener inside initPtt(), lib/ptt.ts). Target UX:

State	Presentation
PTT bound, released	Muted; hint "Hold {key} to talk"
PTT pressed	Unmuted + speaking ring
binding a key	Keybinds tab: "Press a key…" (10 s capture window, `ptt_listen_for_key`); reject text keys with "Pick a non-text key"
PTT thread error	Toast "Push-to-talk stopped unexpectedly" on `ptt-error`, offer re-enable

5. Voice roster (per channel)

The channel's voice roster renders from voiceUsers. Each participant tile reflects their speaking/muted/deafened/camera/screenshare. Target:

Signal	Tile reaction
`voice_state`	Add/update the participant with their flags
`voice_leave`	Remove the tile; if it's us (kick/disconnect), clear local voice state (already the `voice_leave` handler in `wireDispatcher()`, `lib/dispatcher.ts`)
`voice_speakers`	Speaking ring on the listed users
key-holder change	Invisible to users (re-election is automatic on leave); no UI churn

Per-user volume is adjustable and persisted (userVolume_{id} in the Rust store).

6. Token refresh & reconnect (invisible)

Token refresh (23 h timer) and voice reconnect (≤2 attempts, 3 s apart) should be invisible on success. Only exhaustion surfaces: "Voice connection lost — failed to reconnect" + auto-leave. The 60 s token-refresh response guard and the forward-secrecy keypair rotation on reconnect are mechanics the user never sees.

7. E2EE identity verification surface

Peer identity state lives in voice.store (per-participant status: verified | unverified | mismatch + safetyNumber), written by lib/livekitE2EE.ts as announces are verified against the pinned identity keys (lib/identity.ts).

State	Roster badge (`verifyPresentation()`, `components/ChannelSidebar.ts`)	Interaction
`verified`	Green shield; title "Identity verified · Safety number: {n}"	none needed
`unverified`	Neutral shield; no pinned key yet	none — pins on first verified announce
`mismatch`	Red shield-alert; title "Identity key changed — click to review and re-pin"	Click → blocking identity-mismatch modal

The mismatch modal (createIdentityMismatchModal(), components/CertMismatchModal.ts; opened from openIdentityMismatchModal() in components/ChannelSidebar.ts) shows the new key's fingerprint so the user can verify it out-of-band before trusting. "Trust New Key" re-pins via rePinPeerIdentity — deliberately pinning the exact key whose fingerprint was displayed, not a fresh store read, so a malicious server cannot swap the key during the human verification window (TOCTOU). Reject leaves the peer blocked for E2EE media. A stripped or malformed published key disables the trust action entirely (a blind accept is refused).

8. Media processing & devices

Noise suppression: RNNoise WASM worklet (lib/noise-suppression.ts, assets public/rnnoise.wasm + public/rnnoise-worklet.js), toggled in Settings → Voice & Audio; falls back to a ScriptProcessorNode pipeline when AudioWorklet is unavailable (createScriptProcessorPipeline() in lib/noise-suppression.ts).
Input volume & VAD: lib/audioPipeline.ts applies input gain and voice-activity gating ahead of publish.
Device hot-swap: lib/deviceManager.ts follows OS device plug/unplug and re-routes the active input/output without rejoining.
Stream preview: lib/streamPreview.ts renders the pre-share preview in the screen-share picker.

9. DM calls (ring)

DM voice is the same voice machinery on the DM's voice channel, plus a ring layer (no server-side call state — presence in the DM voice channel is the call):

Event	Reaction
Outgoing: user clicks Call	`call_ring` sent (rate-limited 1/3 s server-side); caller joins the DM voice channel
Incoming: `call_incoming`	`components/IncomingCallBanner.ts` banner + ring chime (`lib/notifications.ts`), driven by the `lib/call-ring.ts` state machine (30 s auto-timeout)
Accept	Join the DM voice channel; banner clears
Decline	`call_decline` sent → other participants' ringing stops via `call_declined`
Timeout / caller leaves	Banner clears silently

call_incoming / call_declined are page-scoped listeners in MainPage.ts, not dispatcher handlers (see README §4).

Source of truth

src/lib/livekitSession.ts, src/lib/livekitE2EE.ts, src/stores/voice.store.ts, src/lib/screenShare.ts, src/lib/ptt.ts, src/lib/roomEventHandlers.ts, src/components/VoiceWidget.ts, src/components/ChannelSidebar.ts (voice rows, join freeze on WS reconnect, and the E2EE verification badge), src/components/VideoGrid.ts, src-tauri/src/livekit_proxy.rs, src-tauri/src/ptt.rs, src/lib/e2eeCrypto.ts, src/lib/identity.ts; and the structural map in ../voice-e2ee.md.

16 KiB Raw Blame History