mirror of
https://github.com/kilyabin/psysonic.git
synced 2026-07-21 22:15:40 +00:00
Frank Stellmacher
9fa086c428
* feat(server): ServerProfile.alternateUrl + shareUsesLocalUrl
Additive optional fields on ServerProfile to back the dual-address work.
'alternateUrl' is the optional second endpoint (e.g. LAN counterpart of a
public 'url' or vice versa); 'shareUsesLocalUrl' chooses which of the two
goes into Orbit / entity / magic-string shares when both are set.
Pure schema change — no runtime consumers yet. Single-address profiles
keep the same persisted shape; the optional fields are simply absent.
* feat(server): serverEndpoint module with LAN classification + IPv6
Introduces a single home for connect-/share-layer URL utilities that
the dual-address work will build on:
* normalizeServerBaseUrl(raw) — aligned with serverProfileBaseUrl
* isLanUrl(url) — IPv4 (unchanged) + IPv6: ::1 loopback, fe80::/10
link-local, fc00::/7 ULA, and IPv4-mapped (both dot-decimal and the
URL-API-normalized hex form, since new URL() rewrites ::ffff:1.2.3.4
to ::ffff:HHHH:HHHH)
* allNormalizedAddresses(profile) — deduped [url, alternateUrl?]
* serverAddressEndpoints(profile) — LAN-first ServerEndpoint[]
isLanUrl moves out of useConnectionStatus.ts (the hook now imports +
re-exports it for backward compatibility); OrbitStartModal points at
the new path directly. 38 unit tests cover the IPv4/IPv6 matrix,
dedupe, ordering, and edge cases.
* feat(server): pickReachableBaseUrl with in-memory connect cache
Adds the runtime connect layer on top of serverEndpoint:
* pickReachableBaseUrl(profile) — sequential LAN-first ping via the
existing pingWithCredentials; first OK wins.
* ensureConnectUrlResolved(profile) — boot / switch / online-event
entry point (same mechanism, intent-named).
* In-memory cache keyed by profileId; sticky behaviour tries the
cached endpoint first, falls back to the natural order on miss.
* invalidateReachableEndpointCache(profileId?) — single-profile and
whole-cache flushes for profile-edit / credentials-change / online.
* getCachedConnectBaseUrl(profileId) — sync getter for getBaseUrl
fallback path (next commit).
The cache is **session-only**, never persisted. Single-address profiles
keep the same shape (one endpoint, one ping). 9 new unit tests cover
single + dual address, LAN-first preference, fallthrough, unreachable +
stale-cache clear, sticky hit, and the two invalidate flavours.
* feat(server): getBaseUrl reads connect cache, falls back to primary url
Dual-address profiles need 'getBaseUrl' to return the runtime-probed
connect URL (LAN at home, public elsewhere), not the literal primary
'url'. To keep the sync getter shape that ~60 call sites depend on,
the store now reads 'getCachedConnectBaseUrl(server.id)' from the
serverEndpoint cache.
If no probe has run yet (very early boot, before switchActiveServer
populates the cache), it falls back to the normalized primary URL —
identical to today's behaviour. Single-address profiles see no
difference; their cache entry equals serverProfileBaseUrl(url).
* feat(server): switch + connection-status probe via ensureConnectUrlResolved
Both surfaces that previously called pingWithCredentials(server.url, ...)
directly now route through the dual-address connect layer:
* switchActiveServer awaits ensureConnectUrlResolved(server), reads the
identity (type/serverVersion/openSubsonic) off the returned ping, and
hands probe.baseUrl (not server.url) to scheduleInstantMixProbeForServer
so the AudioMuse probe also hits the reachable endpoint.
* useConnectionStatus.check() does the same on every 120 s tick — sticky
cache fast-paths the steady state, and a network change naturally
flips the active endpoint without a manual retry.
* useConnectionStatus.retry() and the 'online' event flush the cached
entry for the active profile first, so the next probe starts from the
natural LAN-first order instead of revalidating a stale URL.
Single-address profiles behave identically: one endpoint in the list,
one ping per check. No behaviour change for them.
* feat(server): PickReachableResult.ping + connectBaseUrlForServer helper
Two additive extensions to the serverEndpoint surface that the upcoming
CONNECT migrations all need:
* 'ping: PingWithCredentialsResult' on the OK branch of
PickReachableResult so callers (switchActiveServer,
useConnectionStatus) can read type/serverVersion/openSubsonic from
the same probe instead of issuing a second pingWithCredentials.
* connectBaseUrlForServer(server) — sync getter for the connect URL
of *any* saved profile (active or not). Reads the cache, falls back
to normalized primary url on miss. Becomes the canonical helper
for non-active-server HTTP traffic (apiForServer, stream URLs,
cover fetches, library bind session).
Tests: pingOk() fixture now returns identity fields; the single
toEqual-asserting test in pickReachableBaseUrl became a guarded read
to keep equality concise while still asserting on the new ping field.
* feat(connect): apiForServer + stream URLs route via connectBaseUrlForServer
Non-active-server HTTP traffic (the apiForServer entry point, used by
QueuePanel cross-server cover fetches and share-paste resolution) and
the stream-URL builders previously read 'server.url' directly,
bypassing the dual-address connect cache. Both now go through
connectBaseUrlForServer, which serves the cached LAN/public endpoint
when one exists and falls back to the normalized primary url
otherwise.
buildStreamUrl(id) now uses the baseUrl it already pulled from
getBaseUrl() (which is connect-cache aware as of 2a6d8283) instead of
re-normalizing server.url — same value for single-address profiles,
correctly dual-address for the rest. Single-address callers see no
behaviour change.
* feat(connect): cover fetch + cover-cache ensure use connect URL
Both cover-fetch surfaces previously read 'scope.url' / 'server.url'
straight into HTTP requests, which would freeze the cover pipeline on
the primary URL even when a LAN endpoint was reachable:
* buildCoverArtFetchUrl(ref, tier) — for the 'server' scope (queue
rows cached against a non-active profile) and the 'playback' scope
(cross-server playback) now resolves the connect URL via
connectBaseUrlForServer before handing off to
buildCoverArtUrlForServer.
* ensureArgsFromRef in coverCache.ts — restBaseUrl for the Tauri
'cover_cache_ensure' invoke now uses the cached connect URL for
both 'server' and 'active'/'playback' scopes.
Scope.url itself remains the index-stable primary URL — that's what
storageKeys (INDEX) consume. Only the HTTP base shifts to the connect
endpoint, exactly the split the spec calls out.
* feat(connect): library bind + server-test probe via ensureConnectUrlResolved
Two more 'rebind / re-test an existing saved server' paths still pinged
the literal primary URL — both go through the dual-address connect
layer now:
* bindIndexedServer (librarySession.ts): used to ping server.url then
pass serverProfileBaseUrl(server) as the bind 'baseUrl' to Rust.
Now: one ensureConnectUrlResolved call covers both — probe.baseUrl
feeds librarySyncBindSession directly, so Rust's per-server library
sync uses whichever endpoint actually answered. Drops the
pingWithCredentials and serverProfileBaseUrl imports.
* testConnection (ServersTab.tsx): same shape — probe via the connect
layer, read identity from probe.ping, hand probe.baseUrl to
scheduleInstantMixProbeForServer so the AudioMuse probe also hits
the connect endpoint. Single-address profiles still ping once.
Add/edit save handlers (handleAddServer / handleEditServer) keep the
direct pingWithCredentials against the user-entered data.url — that
flow is the dual-address verify hook, which PR 2 extends.
* feat(server): serverShareBaseUrl — public-by-default share URL picker
Adds the share-layer companion to connectBaseUrlForServer. Different
intent: connect picks the reachable endpoint for HTTP, share picks the
URL that goes into Orbit invites / entity share payloads / queue share
links / magic strings — where a guest opening the link is not on the
host's LAN.
Logic per spec §5.1:
* Single-address profile → that one address (normalized).
* Both set, default flag → public.
* Both set, shareUsesLocalUrl flag → local.
* Edge cases (both LAN, both public, missing one of the two): fall
back to the first endpoint in the list so the function is total.
Empty profile returns the normalized url (possibly empty) — defensive,
never throws. 7 unit tests pin all six branches plus the empty case.
Call-site migration (Orbit, copyEntityShareLink, QueuePanel, magic
string srv field, findServerIdForShareUrl, Orbit LAN warning) lands
in the next commits.
* feat(share): Orbit + entity + queue shares use serverShareBaseUrl
Four share-encoding surfaces previously read 'getBaseUrl()' (connect)
or the raw 'server.url' (primary) when embedding the host into outgoing
share links — both wrong for a dual-address profile:
* copyEntityShareLink (track / album / artist / composer) — was
getBaseUrl(); now reads serverShareBaseUrl(active). Guests opening
the link are off-LAN, so public is the right default.
* OrbitStartModal — was raw server?.url for both 'buildOrbitShareLink'
and the LAN warning. Now goes through serverShareBaseUrl; the LAN
warning correspondingly reflects the address the guest will see,
not the host's primary.
* OrbitSharePopover — same fix on the host-only share popover.
* QueuePanel.handleCopyQueueShare — was getBaseUrl(); same migration.
Single-address profiles return exactly the same string from
serverShareBaseUrl as serverProfileBaseUrl(server.url) did before, so
no behaviour change for the common case. shareUsesLocalUrl flips the
default to LAN for the rare 'share into a LAN-only group' use; that
checkbox lands with the form UI in the next sub-phase.
findServerIdForShareUrl + paste-side share matchers are migrated in
the next commit (read-side of the same contract).
* feat(share): paste-side resolves dual-address profiles + connect URL
Read-side counterpart to the encode-side migration:
* findServerIdForShareUrl(servers, shareSrv) now matches a profile
when shareSrv normalizes to either profile.url OR profile.alternateUrl.
Without this, a paste of a link generated against the host's LAN
address (shareUsesLocalUrl=true) would fail to find the local saved
profile even though it's the same server.
* resolveSharedSong / resolveShareSearchAlbum / resolveShareSearchArtist
in enqueueShareSearchPayload now hand connectBaseUrlForServer(lookup.server)
to the *WithCredentials HTTP calls instead of the raw lookup.server.url.
The looked-up profile may be dual-address; this routes the song / album /
artist fetch through whichever endpoint is currently reachable.
Indirect consumers (shareServerOriginLabel, shareQueueServerContext) read
the same findServerIdForShareUrl, so no code change needed there — they
now match both addresses transparently.
* feat(verify): serverFingerprint + same-server verification
Pure-logic core of dual-address verify. Three exports:
* fetchServerFingerprint(baseUrl, user, pass) — one ping (envelope
'version' extracted alongside type/serverVersion/openSubsonic) plus
four soft-fail optional calls in parallel (getMusicFolders, getUser,
getLicense, getIndexes). Optional failures collapse to null fields,
not whole-fingerprint failure. Subsonic-generic — never branches on
type === 'navidrome'. indexesDigest is a hash of letter-count plus
sorted first 20 artist ids, so two probes against the same library
see the same digest without comparing full payloads.
* compareFingerprints(a, b) — strict on the ping triple
(type case-insensitive, serverVersion exact, openSubsonic boolean);
envelope apiVersion informational only. Body signals counted only
when both sides have a non-null value; empty musicFolders [] on both
sides still counts as a matching signal. Result: 'match' (>=1 common
signal all agreeing) / 'mismatch' (any common differs) /
'insufficient' (0 common). No 'save anyway' for insufficient in v1.
* verifySameServerEndpoints(profile, user, pass) — single-address
short-circuits to ok:true (nothing to verify). Otherwise parallel
fingerprint probes, then pairwise compare. Ping-fail on any
endpoint reports the offending host for the UI.
20 unit tests cover the compare matrix (every body signal in every
direction), Navidrome- vs minimal-Subsonic-shape probes, ping-fail,
and all four verify outcomes (ok / unreachable / mismatch /
insufficient). HTTP mocked via vi.stubGlobal('fetch') + plain-object
Response shape (avoiding any Response-polyfill dependency).
* feat(boundary): resolve_host_addresses Tauri command + TS wrapper
Adds one additive invoke for dual-address form hints. Spec §9.1
+ contracts.md §6.
Rust side (src-tauri/src/lib_commands/app_api/network.rs):
* #[tauri::command] resolve_host_addresses(hostname: String) ->
Result<Vec<String>, String>
* tokio::net::lookup_host with a port suffix (':0'); discards the
port from each SocketAddr, dedupes addresses via HashSet.
* strip_port helper handles 'host:port', 'ipv4:port',
'[ipv6]:port', '[ipv6]' (no port), and bare 'ipv6' (left as-is
for lookup_host to wrap). 7 unit tests cover each shape.
* Lookup failure → Ok(vec![]) so a DNS hiccup doesn't surface as
an error toast or block the save flow — form-hint only.
Frontend wrapper (src/api/network.ts):
* resolveHostAddresses(hostname) — trims, invokes, swallows errors
to an empty array so consumers get a clean total function.
§04 boundary note: additive command, no breaking change. Added to
the invoke_handler! generate_handler list in lib.rs at the natural
alphabetical-ish slot near migration_run.
* feat(form): AddServerForm — second optional address + share flag + DNS hint
UI side of dual-address. AddServerForm now carries the four new
moving parts spec §6 calls out:
* Second address field ('Second address (optional)') under the
primary URL. Placeholder flips to suggest the opposite kind
of address based on the primary's LAN classification.
* Contextual hint under the second field when it's empty —
'add a public address for outside-home use' (primary is LAN)
or 'add a local address for faster home access' (primary is
public). Hint disappears once the field has content.
* Two-LAN client-side check on submit: when both addresses
classify as LAN, save is blocked with a toast. Reverse case
(both public) intentionally allowed per spec §6.3.
* shareUsesLocalUrl checkbox — visibility rule per spec §5.3:
hidden until the second address has content; shows with the
persisted value on edit; cleared when the user empties the
second address before save.
DNS hint: on primary-URL blur we call the Tauri
resolve_host_addresses command and classify the response by
isLanUrl. Literal IPs skip DNS (already classified locally). DNS
miss → no hint surfaces (never blocks save). Used only for the
hint text — connect still goes through pingWithCredentials.
i18n: 9 new keys in en + ru (serverAlternateUrl*, shareUsesLocalUrl*,
serverBothLanError). Other locales fall back to English.
onSave signature widened to 'void | Promise<void>' — ServersTab /
Login both accept that already. The save flow itself still calls
the legacy pingWithCredentials path; verify wiring lands in 2e.
* feat(verify): wire verifySameServerEndpoints into add + dual-edit flows
Save flow now blocks persisting a dual-address profile that fails the
same-server check. Spec §6.4 + §7.4.
handleAddServer:
* When data.alternateUrl is non-empty, runs verifySameServerEndpoints
BEFORE the existing ping. mismatch / insufficient / unreachable each
surface a localized toast and abort the save (no addServer call).
* Single-address adds keep the legacy single-ping path — no extra
network round-trip when there's nothing to verify.
handleEditServer:
* Unconditional save remains the default — but if the edit either
introduces / changes alternateUrl OR changes url / username / password
while alternateUrl is set, verify runs first and may block.
* After persist, invalidates the reachable-endpoint cache for this
profile id so any sticky cached connect URL from before the edit is
re-probed on the next access (credentials may have changed, alternate
may have appeared).
i18n: 4 new toast keys in en + ru (dualAddressVerifying placeholder for
future progress UI, plus mismatch / insufficient / unreachable). Other
locales fall back to English.
announceVerifyResult helper keeps the toast routing in one place so
handleAddServer and handleEditServer share the same surface.
* i18n(settings): dual-address keys across all 9 locales
Adds the 13 new dual-address keys to the remaining 7 locales:
de · fr · es · nl · nb · ro · zh.
* serverAlternateUrl + placeholderPublic / placeholderLocal
* serverAlternateUrlHintAddPublic / HintAddLocal (contextual hints
under the second-address field)
* serverBothLanError (client-side two-LAN validation)
* dualAddressVerifying / Mismatch / Insufficient / Unreachable
(toast strings; Unreachable carries the {{host}} interpolation)
* shareUsesLocalUrl + Desc (checkbox label + short description)
Placeholders (example.com URL / 192.168.1.100:4533) kept identical
across all locales — same shape the existing serverUrlPlaceholder
already uses.
Single coordinated sweep so every supported language ships dual-
address fully translated rather than falling back to English.
* feat(cover): cover_cache_rename_server_bucket Tauri command
Adds the disk-side companion to the upcoming URL-change remigration
flow (dual-server-address spec §8.3). When a user edits the primary
url so the derived index key changes, the SQLite migration already
re-tags rows via the existing migration_run command — this command
moves the cover-cache bucket on disk so cached WebP tiles stay
reachable under the new key.
Behaviour:
* old_key == new_key → no-op.
* Old bucket missing → no-op success (nothing to migrate).
* New bucket missing → simple fs::rename (fastest path).
* Both exist → recursive merge with 'prefer existing' on file
collision (the newer bucket wins; data is never lost).
* Emits 'cover:bucket-renamed' with {oldKey, newKey} on success
so the frontend disk-src cache can invalidate stale URLs.
Sanitization: rejects empty, backslash, and '..' path segments at
the FS boundary. Forward slashes are legitimate (a Navidrome
mounted at a subpath like 'music.example.com/navidrome' produces
an index key with one); they're handled by Path::join.
4 unit tests cover key sanitization (accepts real keys, rejects
traversal/backslash) and the merge semantics (unique-file move +
prefer-existing on collision). Registered in lib.rs invoke handler.
* feat(remap): rewriteFrontendStoreKeysForRemap — explicit oldKey→newKey path
Adds the URL-change remigration entry point next to the existing
UUID→indexKey migration. Same plumbing (offline store, hot cache,
analysis-strategy maps) but driven by explicit { oldKey, newKey }[]
mappings instead of being derived from the current servers list.
Also folds in the player-side cleanup the existing path didn't have:
* queueServerId — if currently bound to a remapped index key,
repoint to the new one so playback continues through the rename
instead of looking unbound.
* analysisStrategyStore — runs the same map-key swap inline (the
'migrateServerOverrides' helper handles UUID→indexKey, not
indexKey→indexKey).
Same prefer-existing-on-collision semantics as the disk-side
cover_cache_rename_server_bucket — if a destination key already
carries data, we keep it. 8 unit tests cover no-ops, the four
store rewrites, the queue repoint, the 'leave other servers
untouched' guarantee, and the collision case.
* feat(remap): serverUrlRemigration orchestrator — 4-stage pipeline
Single-file orchestrator that runs the full URL-change remigration when
a profile edit shifts the primary url's derived index key. Spec §8 +
contracts.md §4.
Two exports:
* indexKeyRemapForUrlChange(prev, next): IndexKeyRemap | null
— short-circuits scheme-only edits ('http://x' ↔ 'https://x'),
trailing-slash differences, and alternateUrl-only changes by
normalizing both sides through serverIndexKeyFromUrl and
returning null when they match. Empty urls also return null.
* runIndexKeyRemigration(remap): Promise<IndexKeyRemigrationResult>
— runs inspect → run → frontend-rewrite → cover-rename in order,
aborts on the first failure and reports the offending stage.
Failure ordering rationale:
* inspect / run failures stop the destructive step — DB is
untouched, the caller can retry safely.
* frontend rewrite swallows errors (best-effort; zustand persist
catches up on rehydrate next session).
* cover-rename failure is reported but does NOT roll back the DB
rows (that would be even more destructive); covers under the
old key recover via the existing cover backfill on next access.
10 tests cover the detect logic (5 cases including the path-suffix
case) plus all four pipeline stages with mocked Tauri invoke —
including verifying the legacyId/indexKey mapping shape lands on
both inspect and run calls.
* feat(remap): wire URL-change remigration into ServersTab edit flow
handleEditServer now detects a primary-url index-key change BEFORE
any other save logic (verify, persist, etc.) and orchestrates the
full remigration when one is needed.
Flow:
* indexKeyRemapForUrlChange(prev, next) — null for scheme-only
edits / alternateUrl-only edits / no-op edits, so the common case
falls straight through without prompting the user.
* On a real remap → confirm modal via useConfirmModalStore.request
(danger style, plain-language oldKey → newKey copy, explicit
'cannot be undone'). User cancel → abort save entirely.
* On confirm → runIndexKeyRemigration pipeline. Failure surfaces a
stage-specific toast (inspect / run / cover-rename — wording per
spec §8.4 + the recoverability matrix in serverUrlRemigration.ts).
* On success → fall through to the existing dual-address verify,
then auth.updateServer + invalidate cache + ping (unchanged).
i18n: 7 new keys (urlRemigrationTitle / Message with oldKey + newKey
interpolation / Confirm / Progress / FailureInspect / FailureRun /
FailureCoverRename) — full sweep across all 9 locales (en, de, ru,
fr, es, nl, nb, ro, zh).
Test fixup: the offline-store collision test in rewriteFrontendStoreKeys
needed an 'as unknown as' cast — the existing OfflineTrackMeta type
doesn't carry the test-only marker property, and a one-step cast
TS rejected as not overlapping enough.
* feat(magic): magic-string v2 encode/decode with dual-address fields
Adds the v2 wire format for server invites. Spec §10 + contracts.md §5.2.
Encode is opportunistic: payloads with alternateUrl set OR
shareUsesLocalUrl=true emit v2; everything else stays v1 byte-identical.
This means single-address profiles keep producing exactly the same
invite they did before — older receivers can't tell the difference.
v2 shape: { v: 2, url, alt?, shareLocal?, u, w, n? }
* url — the host's share URL (public by default; LAN if shareLocal),
NOT necessarily the host's primary URL. Receiver treats it as the
primary of the new profile (their own index key).
* alt — the host's alternate address (the other half of the pair).
* shareLocal — mirrors the host's shareUsesLocalUrl preference so
onward shares from the receiver behave the same way.
Decode accepts both v1 and v2. v2-only fields are left undefined when
decoding a v1 payload (no '|| undefined' shim — kept absent so zustand
persist diffs stay clean). Defensive: an empty alt on a v2 invite
decodes as if the field were absent, never as ''.
Test updates: 'rejects a payload with the wrong version' now targets
v: 3 (v: 2 became valid). 7 new tests cover the v1/v2 wire-format
choice, both v2 round-trip shapes, the v1-decode-into-v2-fields-
undefined backward-compat case, and the empty-alt edge.
* feat(magic): wire magic-string v2 through invite-encode + paste consumers
Five surfaces now produce / accept v2 invites with the dual-address
fields end-to-end:
Encode side (admin → user invite):
* MagicStringModal — looks up the saved profile that matches the
serverUrl prop (primary OR alternateUrl normalize-match) and
encodes through serverShareBaseUrl + alternateUrl + the share
flag. Falls back to plain v1 for single-address profiles.
* UserForm — same lookup + encode plumbing on the in-form
'Save & get magic string' flow.
Decode side (paste invite into form):
* AddServerForm useEffect (initialInvite from outer state) +
handleMagicStringChange (live paste) both pull alternateUrl
and shareUsesLocalUrl off the decoded payload into form state,
so the second-address field + checkbox surface immediately on a
v2 paste.
* Login form state gains hidden alternateUrl + shareUsesLocalUrl
fields (not user-editable — Login stays single-address by
design); v2 paste / initial-invite both populate them so they
persist with the new profile via addServer. handleQuickConnect
likewise forwards the existing dual-address shape for
already-saved profiles.
* attemptConnect signature widened with the two optional fields;
addServer / updateServer call sites conditionally include them
only when alternateUrl is non-empty so single-address profiles
keep their lean persisted shape.
Both encode helpers share the same magicPayloadAddressFields lookup
(MagicStringModal + UserForm) — the duplication is acceptable for
two co-located small files but a single shared helper would be the
natural place to consolidate if a third encoder appears.
* fix(form): magic-string submit forwards decoded alternateUrl + share flag
AddServerForm.submit's magic-string branch was forwarding only
name/url/username/password from the decoded payload, silently dropping
alternateUrl + shareUsesLocalUrl. A v2 invite pasted into the
magic-string field and saved would land in the store as a single-
address profile even though handleMagicStringChange had already
populated the dual-address fields into form state for display.
Now the magic branch picks the dual-address fields off the decoded
payload (same conditional spread as the non-magic branch a few lines
down) so v2 invites round-trip end-to-end through the form.
* fix(verify): extractUserId drops username fallback to avoid false mismatches
Spec §7.2 footnote: 'fallback (normalized username) only if no id on
either side'. The old extract unconditionally fell back to the
authenticated username whenever user.id was empty — but the
comparator can't tell username-fallback apart from a server-supplied
id. So a server pair where endpoint A returns user.id='42' and
endpoint B only returns user.username='frank' would land in compare
with userId values '42' vs 'frank' and report mismatch on what is
actually the same user on the same server.
Now extractUserId returns null when user.id is absent. Both sides
returning null means compareFingerprints skips userId as a common
signal (correct behaviour per the §7.3 'both sides have a value'
rule). One new test pins it; the call site drops the redundant
fallbackUsername argument.
* fix(remap): rewriteFrontendStoreKeysForRemap migrates coverStrategyStore
Spec §8.2 lists 'analysis/cover strategy maps' as targets of the
URL-change remigration. The For-Remap path covered analysis but
missed cover — a user-set cover strategy override (e.g. 'aggressive'
for one server) would silently drop when the user edited that
profile's primary URL, because the key tagged under the old index
key never made it to the new one.
Same shape as the analysis remap inline: prefer-existing on
collision (newer key wins), delete the legacy entry afterwards.
One new test pins the move; setup adds a fresh useCoverStrategyStore
reset between cases.
* fix(cover): is_safe_index_key rejects absolute paths + drive letters
Defense-in-depth gap in cover_cache_rename_server_bucket. The old
sanitizer only rejected backslashes and '..' segments — '/etc/passwd'
on Unix and 'C:\Windows' on Windows both passed. Path::join with an
absolute argument REPLACES the base path, so root.join('/etc/passwd')
on Unix would walk out of cover-cache entirely.
Real index keys never reach this state — they come out of
serverIndexKeyFromUrl which strips schemes and trailing slashes, so
no leading separator and no drive-letter prefix is ever produced.
But the comment promises 'defense in depth' and that defense is
worth completing.
Now rejects:
* empty keys (would join to the cover-cache root itself)
* leading '/' or '\'
* Windows drive-letter prefix 'X:' (case-insensitive ASCII letter)
* backslashes anywhere (separators are forward-slash only)
* '..' segments after split('/')
One new Rust test covers all four cases.
* fix(connection): isLan badge reflects active endpoint, not primary url
useConnectionStatus.isLan was reading isLanUrl(server.url) — the
*primary* address — so a dual-address profile that had fallen over to
its public alternate kept advertising 'LAN' in the badge until the
user looked at the server URL itself. Spec call-site-checklist line
25: 'active endpoint kind for badge (LAN vs extern)'.
Now: ensureConnectUrlResolved returns probe.endpoint.kind on success;
the hook tracks the latest kind in local state and surfaces that.
Pre-first-probe fall-through keeps the old primary-URL classification
so the badge has something to render at mount time.
Three tests pin the three states (LAN-active after probe, public-
active after fallback, primary-fallback before first probe completes);
plus one for the online-event handler that invalidates the cache and
re-probes.
* fix(server): dedupe concurrent pickReachableBaseUrl calls for same profile
Multiple call sites probe on roughly the same beat — useConnectionStatus
120-s tick + online handler + initial mount, switchActiveServer,
bindIndexedServer, and ServersTab.testConnection. Two near-simultaneous
probes for the same profile both observed an empty cache, both pinged
every endpoint, and raced to write the sticky URL with last-write-wins.
On a dual-address profile the slower probe could stomp the correct
LAN sticky a millisecond after it was set.
Now: an in-flight Map<profileId, Promise<PickReachableResult>>; a
second call for the same id during an active probe returns the same
promise instead of starting a fresh one. The finally-clear keeps the
dedup window narrow (one settled probe → next call probes fresh).
invalidateReachableEndpointCache deliberately doesn't touch the
in-flight map — the racing probe's own finally will clean up.
Three tests pin it: two concurrent calls share one ping; a fresh
call after the previous settled does ping again; plus the existing
shareBaseUrl two-LAN-with-flag-on test + the two-public-default test
for completeness.
* refactor(magic): extract magicPayloadAddressFields to single shared helper
The lookup that turns a serverUrl into the v2-encode-ready
{ url, alternateUrl?, shareUsesLocalUrl? } shape was duplicated
byte-identically between MagicStringModal.tsx and UserForm.tsx —
both Navidrome admin user-mgmt encode sites. Workdocs §03 / §1a
'one source of truth for behavior'.
Now lives in src/utils/server/serverMagicString.ts as a named
export. Both call sites import + pass the current servers list
(via useAuthStore.getState().servers) — keeps the helper pure so
it's straight to unit-test if a third encoder ever appears.
* fix(cover): wire cover:bucket-renamed listener for URL-change remigration
cover_cache_rename_server_bucket emits cover:bucket-renamed on
successful rename / merge, but no frontend listener was wiring it in.
After a URL-change remigration the in-memory disk-src cache still
held entries pointing at `{root}/{oldKey}/…/.webp` paths the disk
no longer carries — the next read would serve a stale URL until
the entry naturally aged out.
New: forgetDiskSrcForServer(serverIndexKey) in diskSrcCache drops
every cover entry under one server key in one pass (the existing
forgetDiskSrcPrefix needs a non-empty coverArtId and can't blanket-
clear a server). useCoverArtBridge subscribes to cover:bucket-
renamed and calls it with oldKey.
Tests: forgetDiskSrcForServer happy path, empty-key defensive
no-op, no-match no-op; plus a regression-pin on the existing
forgetDiskSrcPrefix so the two helpers don't drift in semantics.
* test(dual-server): fill the high-impact coverage gaps from the branch review
Adds the tests the review identified as missing on the hot-path UI
flows + the partial-fail / alt-only edges:
* AddServerForm.test.tsx (new) — five component tests:
single-address save / dual-address save / two-LAN block-with-
toast / v2 magic-string paste forwarding alt + share flag /
edit-flow stripping alt+flag when the field is emptied.
* Login.test.tsx (new) — v2 invite paste persists alternateUrl +
shareUsesLocalUrl onto the saved profile; v1 invite leaves
those fields undefined.
* shareLink.test.ts — alternateUrl-only match for
findServerIdForShareUrl (the dual-address paste case where the
host shared the LAN URL via shareUsesLocalUrl=true); 'first hit
wins' across two profiles where both match.
* serverFingerprint.test.ts — partial-fail mix (folders+user ok,
license+indexes rejected) so a Promise.allSettled regression
wouldn't go silent.
* cover_cache/mod.rs — rename_bucket_inner extracted as a
testable FS-only helper (the Tauri command wrapper now just
locks state + calls it + emits the event), plus six tests
covering empty/unsafe keys, no-op-when-missing, no-op-when-
equal, simple-rename, merge-with-prefer-existing.
Also: every test fixture that I authored on this branch using
'frank' / 'frank@example.com' as a stand-in username/email
swapped to 'tester' / 'tester@example.com' — keeping personal
names out of test data is the codebase convention (see
factories.ts) and is now a memory rule.
* fix(test): typed mock access for pingWithCredentials in useConnectionStatus
vi.mocked(...) returns the mock typed properly — bare .mock fails
tsc because the imported function signature isn't a vi.Mock at
import time.
* docs(changelog): dual server address (PR #880)
* fix(test): align diskSrcCache tests with main cover storage key API
After rebase onto main, forgetDiskSrcPrefix takes a CoverArtRef-shaped
argument and storage keys include cacheKind; merge coverDiskUrl tests
from main with dual-address forgetDiskSrcForServer coverage.
610 lines
42 KiB
TypeScript
610 lines
42 KiB
TypeScript
export const settings = {
|
||
title: 'Paramètres',
|
||
language: 'Langue',
|
||
languageEn: 'English',
|
||
languageDe: 'Deutsch',
|
||
languageEs: 'Español',
|
||
languageFr: 'Français',
|
||
languageNl: 'Nederlands',
|
||
languageNb: 'Norsk',
|
||
languageRu: 'Русский',
|
||
languageZh: '中文',
|
||
languageRo: 'Română',
|
||
font: 'Police',
|
||
fontHintOpenDyslexic: 'Adapté à la dyslexie · sans prise en charge du chinois',
|
||
theme: 'Thème',
|
||
appearance: 'Apparence',
|
||
servers: 'Serveurs',
|
||
serverName: 'Nom du serveur',
|
||
serverUrl: 'URL du serveur',
|
||
serverUrlPlaceholder: '192.168.1.100:4533 ou https://music.exemple.com',
|
||
serverAlternateUrl: 'Seconde adresse (optionnelle)',
|
||
serverAlternateUrlPlaceholderPublic: 'https://music.example.com',
|
||
serverAlternateUrlPlaceholderLocal: '192.168.1.100:4533',
|
||
serverAlternateUrlHintAddPublic: 'Vous pouvez ajouter une adresse publique pour y accéder en dehors de votre réseau domestique.',
|
||
serverAlternateUrlHintAddLocal: 'Vous pouvez ajouter une adresse locale pour une connexion plus rapide à domicile.',
|
||
serverBothLanError: 'Les deux adresses sont locales — conservez-en une ou ajoutez une adresse publique.',
|
||
dualAddressVerifying: 'Vérification que les deux adresses pointent vers le même serveur…',
|
||
dualAddressMismatch: 'Les deux adresses pointent vers des serveurs différents. Vérifiez l’orthographe et réessayez.',
|
||
dualAddressInsufficient: 'Impossible de confirmer que les deux adresses correspondent au même serveur. Supprimez une adresse pour continuer.',
|
||
dualAddressUnreachable: 'Impossible de joindre {{host}}. Vérifiez l’adresse et votre réseau, puis réessayez.',
|
||
urlRemigrationTitle: 'Déplacer les données de la bibliothèque ?',
|
||
urlRemigrationMessage: 'Changer l’adresse déplacera toutes les données de la bibliothèque, de l’analyse et du cache de couvertures de {{oldKey}} vers {{newKey}}. Cette action est irréversible.',
|
||
urlRemigrationConfirm: 'Déplacer les données',
|
||
urlRemigrationProgress: 'Déplacement des données de la bibliothèque…',
|
||
urlRemigrationFailureInspect: 'Impossible de vérifier ce qui serait déplacé. Réessayez ou ouvrez le journal de débogage.',
|
||
urlRemigrationFailureRun: 'Le déplacement des données de la bibliothèque a échoué. Vos données enregistrées sont intactes — réessayez.',
|
||
urlRemigrationFailureCoverRename: 'Les données de la bibliothèque ont été déplacées, mais les fichiers de couverture n’ont pas pu être renommés. Les couvertures seront reconstruites au prochain accès.',
|
||
shareUsesLocalUrl: 'Utiliser l’adresse locale dans les liens de partage',
|
||
shareUsesLocalUrlDesc: 'Affecte les invitations Orbit et les partages de bibliothèque. Par défaut : adresse publique.',
|
||
serverUsername: 'Nom d\'utilisateur',
|
||
serverPassword: 'Mot de passe',
|
||
addServer: 'Ajouter un serveur',
|
||
addServerTitle: 'Ajouter un nouveau serveur',
|
||
editServer: 'Modifier',
|
||
editServerTitle: 'Modifier le serveur',
|
||
useServer: 'Utiliser',
|
||
deleteServer: 'Supprimer',
|
||
noServers: 'Aucun serveur enregistré.',
|
||
serverActive: 'Actif',
|
||
confirmDeleteServer: 'Supprimer le serveur « {{name}} » ?',
|
||
serverConnecting: 'Connexion…',
|
||
serverConnected: 'Connecté !',
|
||
serverFailed: 'Connexion échouée.',
|
||
testBtn: 'Tester la connexion',
|
||
testingBtn: 'Test en cours…',
|
||
serverCompatible: 'Conçu pour Navidrome. Les autres serveurs compatibles Subsonic (Gonic, Airsonic, …) peuvent fonctionner avec des fonctionnalités réduites, car Psysonic utilise de nombreux endpoints d’API spécifiques à Navidrome.',
|
||
userMgmtTitle: 'Gestion des utilisateurs',
|
||
userMgmtDesc: 'Gérer les utilisateurs sur ce serveur. Nécessite des privilèges administrateur.',
|
||
userMgmtNoAdmin: 'Vous devez être administrateur pour gérer les utilisateurs sur ce serveur.',
|
||
userMgmtLoadError: 'Impossible de charger les utilisateurs.',
|
||
userMgmtLoadFriendly: 'Le serveur n\'a pas répondu — généralement ponctuel.',
|
||
userMgmtRetry: 'Réessayer',
|
||
userMgmtEmpty: 'Aucun utilisateur trouvé.',
|
||
userMgmtYouBadge: 'Vous',
|
||
userMgmtAdminBadge: 'Admin',
|
||
userMgmtAddUser: 'Ajouter un utilisateur',
|
||
userMgmtAddUserTitle: 'Nouvel utilisateur',
|
||
userMgmtEditUserTitle: 'Modifier l’utilisateur',
|
||
userMgmtUsername: 'Nom d’utilisateur',
|
||
userMgmtName: 'Nom affiché',
|
||
userMgmtEmail: 'E-mail',
|
||
userMgmtPassword: 'Mot de passe',
|
||
userMgmtPasswordEditHint: 'Saisir un nouveau mot de passe pour le modifier.',
|
||
userMgmtRoleAdmin: 'Admin',
|
||
userMgmtLibraries: 'Bibliothèques',
|
||
userMgmtLibrariesAdminHint: 'Les utilisateurs admin ont automatiquement accès à toutes les bibliothèques.',
|
||
userMgmtLibrariesEmpty: 'Aucune bibliothèque disponible sur ce serveur.',
|
||
userMgmtLibrariesValidation: 'Sélectionnez au moins une bibliothèque.',
|
||
userMgmtLibrariesUpdateError: 'Utilisateur enregistré, mais l\u2019attribution des bibliothèques a échoué',
|
||
userMgmtNoLibraries: 'Aucune bibliothèque attribuée',
|
||
userMgmtNeverSeen: 'Jamais',
|
||
userMgmtSave: 'Enregistrer',
|
||
userMgmtCancel: 'Annuler',
|
||
userMgmtDelete: 'Supprimer',
|
||
userMgmtEdit: 'Modifier',
|
||
userMgmtConfirmDelete: 'Supprimer l’utilisateur « {{username}} » ? Action irréversible.',
|
||
userMgmtCreateError: 'Impossible de créer l’utilisateur.',
|
||
userMgmtUpdateError: 'Impossible de mettre à jour l’utilisateur.',
|
||
userMgmtDeleteError: 'Impossible de supprimer l’utilisateur.',
|
||
userMgmtCreated: 'Utilisateur créé.',
|
||
userMgmtUpdated: 'Utilisateur mis à jour.',
|
||
userMgmtDeleted: 'Utilisateur supprimé.',
|
||
userMgmtValidationMissing: 'Nom d’utilisateur, nom affiché et mot de passe sont requis.',
|
||
userMgmtValidationMissingIdentity: 'Le nom d’utilisateur et le nom affiché sont requis.',
|
||
userMgmtMagicStringGenerate: 'Générer la chaîne magique',
|
||
userMgmtSaveAndMagicString: 'Enregistrer et obtenir la chaîne magique',
|
||
userMgmtMagicStringPasswordNavHint:
|
||
'Navidrome enregistrera ce mot de passe pour l’utilisateur. S’il diffère de l’actuel, le mot de passe de connexion sur le serveur sera mis à jour.',
|
||
userMgmtMagicStringPlaintextWarning:
|
||
'Partagez la chaîne magique avec prudence : elle contient un mot de passe non chiffré (l’encodage n’est pas du chiffrement). Quiconque possède la chaîne complète peut se connecter en tant que cet utilisateur.',
|
||
userMgmtMagicStringCopied: 'Chaîne magique copiée dans le presse-papiers.',
|
||
userMgmtMagicStringCopyFailed: 'Impossible de copier dans le presse-papiers.',
|
||
userMgmtMagicStringLoginFailed: 'Échec de la vérification du mot de passe — identifiants non confirmés.',
|
||
userMgmtMagicStringModalTitle: 'Générer la chaîne magique',
|
||
userMgmtMagicStringModalDesc: 'Saisissez le mot de passe Subsonic de « {{username}} ». Il est inclus dans la chaîne magique copiée.',
|
||
userMgmtMagicStringModalConfirm: 'Copier la chaîne',
|
||
audiomuseTitle: 'AudioMuse-AI (Navidrome)',
|
||
audiomuseDesc:
|
||
'Activez si ce serveur utilise le <pluginLink>plugin Navidrome AudioMuse-AI</pluginLink>. Active le mix instantané depuis un morceau et affiche les artistes similaires côté serveur au lieu de Last.fm sur les pages artiste.',
|
||
audiomuseIssueHint:
|
||
'Le mix instantané a échoué récemment — vérifiez le plugin Navidrome et l’API AudioMuse. Les artistes similaires utilisent Last.fm si le serveur ne renvoie rien.',
|
||
connected: 'Connecté',
|
||
failed: 'Échec',
|
||
eqTitle: 'Égaliseur',
|
||
eqEnabled: 'Activer l\'égaliseur',
|
||
eqPreset: 'Préréglage',
|
||
eqPresetCustom: 'Personnalisé',
|
||
eqPresetBuiltin: 'Préréglages intégrés',
|
||
eqPresetCustomGroup: 'Mes préréglages',
|
||
eqSavePreset: 'Enregistrer comme préréglage',
|
||
eqPresetName: 'Nom du préréglage…',
|
||
eqDeletePreset: 'Supprimer le préréglage',
|
||
eqResetBands: 'Réinitialiser à plat',
|
||
eqPreGain: 'Pré-amplification',
|
||
eqResetPreGain: 'Réinitialiser la pré-amplification',
|
||
eqAutoEqTitle: 'Recherche AutoEQ',
|
||
eqAutoEqPlaceholder: 'Rechercher un casque / IEM…',
|
||
eqAutoEqSearching: 'Recherche…',
|
||
eqAutoEqNoResults: 'Aucun résultat',
|
||
eqAutoEqError: 'Échec de la recherche',
|
||
eqAutoEqRateLimit: 'Limite GitHub atteinte — réessayez dans une minute',
|
||
eqAutoEqFetchError: 'Impossible de charger le profil EQ',
|
||
lfmTitle: 'Last.fm',
|
||
lfmConnect: 'Connecter avec Last.fm',
|
||
lfmConnecting: 'En attente d\'autorisation…',
|
||
lfmConfirm: 'J\'ai autorisé l\'application',
|
||
lfmConnected: 'Connecté en tant que',
|
||
lfmDisconnect: 'Déconnecter',
|
||
lfmConnectDesc: 'Connectez votre compte Last.fm pour activer le scrobbling et les mises à jour « En cours de lecture » depuis Psysonic — aucune configuration Navidrome requise.',
|
||
lfmOpenBrowser: 'Une fenêtre de navigateur s\'ouvrira. Autorisez Psysonic sur Last.fm, puis cliquez sur le bouton ci-dessous.',
|
||
lfmScrobbles: '{{n}} scrobbles',
|
||
lfmMemberSince: 'Membre depuis {{year}}',
|
||
scrobbleEnabled: 'Scrobbling activé',
|
||
scrobbleDesc: 'Envoyer les morceaux à Last.fm après 50% d\'écoute',
|
||
behavior: 'Comportement de l\'application',
|
||
cacheTitle: 'Taille max. du stockage',
|
||
cacheDesc: 'Pochettes et images d\'artistes. Quand le cache est plein, les entrées les plus anciennes sont supprimées automatiquement. Les albums hors ligne ne sont pas supprimés automatiquement, mais le seront lors d\'un nettoyage manuel.',
|
||
cacheUsedImages: 'Images :',
|
||
cacheUsedOffline: 'Pistes hors ligne :',
|
||
cacheUsedHot: 'Espace disque :',
|
||
hotCacheTrackCount: 'Pistes en cache :',
|
||
cacheMaxLabel: 'Taille max.',
|
||
cacheClearBtn: 'Vider le cache',
|
||
cacheClearWarning: 'Cela supprimera aussi tous les albums hors ligne de la bibliothèque.',
|
||
cacheClearConfirm: 'Tout supprimer',
|
||
cacheClearCancel: 'Annuler',
|
||
offlineDirTitle: 'Bibliothèque hors ligne (intégrée)',
|
||
offlineDirDesc: 'Emplacement de stockage des titres rendus disponibles hors ligne dans Psysonic.',
|
||
offlineDirDefault: 'Par défaut (données d\'application)',
|
||
offlineDirChange: 'Changer le dossier',
|
||
offlineDirClear: 'Réinitialiser',
|
||
offlineDirHint: 'Les nouveaux téléchargements utiliseront cet emplacement. Les téléchargements existants restent à leur emplacement d\'origine.',
|
||
hotCacheTitle: 'Cache de lecture à chaud',
|
||
hotCacheDisclaimer: 'Précharge les titres à venir dans la file et conserve les précédents. Si activé : espace disque et réseau.',
|
||
hotCacheDirDefault: 'Par défaut (données d\'application)',
|
||
hotCacheDirChange: 'Changer le dossier',
|
||
hotCacheDirClear: 'Réinitialiser',
|
||
hotCacheDirHint: 'Changer de dossier réinitialise l’index dans l’app ; les fichiers déjà écrits restent à l’ancien emplacement.',
|
||
hotCacheEnabled: 'Activer le cache de lecture à chaud',
|
||
hotCacheMaxMb: 'Taille maximale du cache',
|
||
hotCacheDebounce: 'Délai après changement de file',
|
||
hotCacheDebounceImmediate: 'Immédiat',
|
||
hotCacheDebounceSeconds: '{{n}} s',
|
||
hotCacheClearBtn: 'Vider le cache à chaud',
|
||
audioOutputDevice: 'Périphérique de sortie audio',
|
||
audioOutputDeviceDesc: 'Choisissez le périphérique audio utilisé par Psysonic. Les changements sont immédiats et relancent la piste en cours.',
|
||
audioOutputDeviceDefault: 'Défaut système',
|
||
audioOutputDeviceRefresh: 'Actualiser la liste',
|
||
audioOutputDeviceOsDefaultNow: 'sortie système actuelle',
|
||
audioOutputDeviceListError: 'Impossible de charger la liste des périphériques audio.',
|
||
audioOutputDeviceNotInCurrentList: 'absent de la liste actuelle',
|
||
audioOutputDeviceMacNotice: 'Sur macOS, la lecture suit actuellement toujours la sortie audio du système pour des raisons techniques. Changez la cible via Réglages Système → Son ou l\'icône haut-parleur de la barre de menus. Contexte : CoreAudio déclenche une demande d\'autorisation du microphone à l\'ouverture d\'un flux non par défaut — nous l\'évitons en utilisant toujours la sortie système par défaut.',
|
||
hiResTitle: 'Lecture haute résolution native',
|
||
hiResEnabled: 'Activer la lecture haute résolution native',
|
||
hiResDesc: "Force une sortie à 44,1 kHz par défaut pour une stabilité maximale. N'activer que si le matériel et le réseau prennent en charge les hautes fréquences d'échantillonnage (88,2 kHz+).",
|
||
showArtistImages: 'Afficher les images d\'artistes',
|
||
showArtistImagesDesc: 'Charge et affiche les images d\'artistes dans la vue d\'ensemble. Désactivé par défaut pour réduire les E/S disque serveur et la charge réseau sur les grandes bibliothèques.',
|
||
showOrbitTrigger: 'Afficher « Orbit » dans l\'en-tête',
|
||
showOrbitTriggerDesc: 'Le bouton d\'en-tête pour démarrer ou rejoindre une session d\'écoute partagée. Masque-le si tu n\'utilises pas Orbit — tu peux le réactiver ici.',
|
||
showTrayIcon: 'Afficher l\'icône dans la barre système',
|
||
showTrayIconDesc: 'Affiche l\'icône Psysonic dans la zone de notification / barre des menus.',
|
||
minimizeToTray: 'Réduire dans la barre système',
|
||
minimizeToTrayDesc: 'Lors de la fermeture, Psysonic continue de fonctionner dans la barre système au lieu de se fermer.',
|
||
clockFormat: 'Format de l\'heure',
|
||
clockFormatDesc: 'Format de l\'horloge utilisé par l\'ETA de la file d\'attente et l\'aperçu du minuteur de mise en veille.',
|
||
clockFormatAuto: 'Automatique (langue du système)',
|
||
clockFormatTwentyFour: '24 heures',
|
||
clockFormatTwelve: '12 heures (AM/PM)',
|
||
preloadMiniPlayer: 'Précharger le mini-lecteur',
|
||
preloadMiniPlayerDesc: 'Construit la fenêtre du mini-lecteur en arrière-plan au démarrage de l\'application afin qu\'elle affiche son contenu instantanément à la première ouverture. Utilise un peu plus de mémoire.',
|
||
linuxWebkitSmoothScroll: 'Molette fluide (Linux)',
|
||
linuxWebkitSmoothScrollDesc: 'Activé : inertie. Désactivé : pas à la ligne, style GTK.',
|
||
linuxWaylandTextRender: 'Rendu du texte Wayland (Linux)',
|
||
linuxWaylandTextRenderDesc:
|
||
'Le lissage dans l’interface est immédiat. L’accélération matérielle WebKit (net / GPU) est enregistrée et appliquée au prochain lancement — la modifier en direct peut figer WebKitGTK.',
|
||
linuxWaylandTextRenderBalanced: 'Équilibré',
|
||
linuxWaylandTextRenderSharp: 'Net (favorise le CPU)',
|
||
linuxWaylandTextRenderGpu: 'GPU prioritaire',
|
||
linuxWaylandTextRenderMinimal: 'Minimal (lissage CSS par défaut)',
|
||
discordRichPresence: 'Discord Rich Presence',
|
||
discordRichPresenceDesc: 'Affiche le titre en cours de lecture sur votre profil Discord. Discord doit être ouvert.',
|
||
discordCoverSource: 'Source de pochette',
|
||
discordCoverSourceDesc: 'D\'où récupérer la pochette pour votre profil Discord.',
|
||
discordCoverNone: 'Aucune (icône de l\'app uniquement)',
|
||
discordCoverServer: 'Serveur (via infos album)',
|
||
discordCoverApple: 'Apple Music',
|
||
discordOptions: 'Options Discord avancées',
|
||
discordTemplates: 'Modèles de texte personnalisés',
|
||
discordTemplatesDesc: 'Personnalisez les informations affichées sur votre profil Discord. Variables : {title}, {artist}, {album}',
|
||
discordTemplateDetails: 'Ligne principale (details)',
|
||
discordTemplateState: 'Ligne secondaire (state)',
|
||
discordTemplateLargeText: 'Info-bulle album (largeText)',
|
||
nowPlayingEnabled: 'Afficher dans la fenêtre live',
|
||
nowPlayingEnabledDesc: 'Diffuse le titre en cours de lecture vers la vue des auditeurs en direct du serveur. Désactiver pour ne pas envoyer de données de lecture.',
|
||
enableBandsintown: 'Dates de tournée Bandsintown',
|
||
enableBandsintownDesc: 'Affiche les concerts à venir de l\'artiste actuel dans l\'onglet Info. Les données proviennent de l\'API publique Bandsintown.',
|
||
lyricsServerFirst: 'Préférer les paroles du serveur',
|
||
lyricsServerFirstDesc: 'Consulter d\'abord les paroles fournies par le serveur (tags intégrés, fichiers sidecar) avant LRCLIB. Désactiver pour utiliser LRCLIB en priorité.',
|
||
enableNeteaselyrics: 'Paroles Netease Cloud Music',
|
||
enableNeteaselyricsDesc: 'Utiliser Netease Cloud Music en dernier recours lorsque le serveur et LRCLIB ne retournent rien. Meilleure couverture pour la musique asiatique et internationale.',
|
||
lyricsSourcesTitle: 'Sources de paroles',
|
||
lyricsSourcesDesc: 'Choisissez quelles sources interroger et dans quel ordre. Glissez pour réordonner. Les sources désactivées sont ignorées.',
|
||
lyricsSourceServer: 'Serveur',
|
||
lyricsSourceLrclib: 'LRCLIB',
|
||
lyricsSourceNetease: 'Netease Cloud Music',
|
||
lyricsYouLyPlus: 'YouLyPlus (Karaoké)',
|
||
lyricsYouLyPlusDesc: 'Synchronisation mot à mot depuis un backend communautaire (Apple Music, Spotify, Musixmatch, QQ). Essayé en premier ; les sources activées ci-dessous servent de repli.',
|
||
lyricsSourcesFallbackHint: 'Utilisées en repli quand YouLyPlus ne trouve rien. Glisser pour réordonner.',
|
||
lyricsSourcesPrimaryHint: 'Essayées dans l\'ordre. Glisser pour réordonner. Tout désactivé = paroles désactivées.',
|
||
lyricsStaticOnly: 'Afficher les paroles en texte statique uniquement',
|
||
lyricsStaticOnlyDesc: 'Affiche les paroles synchronisées sans défilement automatique ni surlignage des mots.',
|
||
downloadsTitle: 'Export ZIP & Archivage',
|
||
downloadsFolderDesc: 'Dossier de destination pour les albums téléchargés en tant que fichier ZIP sur votre ordinateur.',
|
||
downloadsDefault: 'Dossier de téléchargement par défaut',
|
||
pickFolder: 'Sélectionner',
|
||
pickFolderTitle: 'Sélectionner le dossier de téléchargement',
|
||
clearFolder: 'Effacer le dossier',
|
||
logout: 'Se déconnecter',
|
||
aboutTitle: 'À propos de Psysonic',
|
||
aboutDesc: 'Un lecteur de musique de bureau moderne conçu pour Navidrome. Utilise l\'API Subsonic ainsi que des extensions spécifiques à Navidrome. Basé sur Tauri v2 avec un moteur audio Rust natif — léger et rapide, mais riche en fonctionnalités : barre waveform, paroles synchronisées, intégration Last.fm, égaliseur 10 bandes, crossfade, lecture sans blanc, Replay Gain, navigation par genre et une grande bibliothèque de thèmes.',
|
||
aboutLicense: 'Licence',
|
||
aboutLicenseText: 'GNU GPL v3 — libre d\'utilisation, de modification et de distribution sous la même licence.',
|
||
aboutRepo: 'Code source sur GitHub',
|
||
aboutVersion: 'Version',
|
||
aboutBuiltWith: 'Construit avec Tauri · React · TypeScript · Rust/rodio',
|
||
aboutReleaseNotesLabel: 'Notes de version',
|
||
aboutReleaseNotesLink: 'Ouvrir les nouveautés de cette version',
|
||
aboutContributorsLabel: 'Contributeurs',
|
||
showChangelogOnUpdate: "Afficher 'Quoi de neuf' lors des mises à jour",
|
||
showChangelogOnUpdateDesc: "Affiche une bannière discrète du changelog au-dessus de Now Playing après une mise à jour. Un clic ouvre les notes de version, le X la masque.",
|
||
libraryGridMaxColumnsTitle: 'Grilles de cartes dans la bibliothèque',
|
||
libraryGridMaxColumnsPerfHint: 'Plus de colonnes signifie plus de tuiles par ligne et davantage de travail de mise en page et de peinture — surtout sur de grosses bibliothèques ou du matériel lent.',
|
||
libraryGridMaxColumnsRangeLabel: 'Nombre maximal de colonnes ({{min}}–{{max}})',
|
||
libraryGridMaxColumnsDesc: 'S’applique aux vues album, artiste, liste de lecture, radio, hors ligne et autres pages en cartes. Moins de colonnes = tuiles plus grandes et en général moins de charge CPU.',
|
||
libraryIndexTitle: 'Index local de bibliothèque (aperçu)',
|
||
libraryIndexDesc: 'Conserve une copie locale de la base de morceaux de chaque serveur pour que la navigation et la recherche restent rapides et fonctionnent hors ligne. La synchronisation initiale s’exécute pour tous les serveurs configurés ; les serveurs hors ligne sont réessayés automatiquement.',
|
||
libraryIndexDeltaHint: 'La synchronisation delta en arrière-plan vérifie les serveurs liés toutes les 30 secondes et s’exécute quand c’est dû — en général toutes les 5 à 45 minutes selon la taille de la bibliothèque et la charge.',
|
||
libraryIndexEnable: 'Activer l’index local de bibliothèque',
|
||
libraryIndexEnableAllDesc: 'Indexer et synchroniser tous les serveurs configurés en arrière-plan.',
|
||
libraryIndexNoServer: 'Ajoutez d’abord un serveur.',
|
||
libraryIndexServerListTitle: 'Serveurs indexés',
|
||
libraryIndexAllExcluded: 'Tous les serveurs sont exclus de la synchronisation. Réactivez l’index ou ajoutez un serveur.',
|
||
libraryIndexServerOffline: 'Serveur hors ligne — synchronisation reportée',
|
||
libraryIndexServerDeferred: 'Reportée',
|
||
libraryIndexServerSyncing: 'Synchronisation…',
|
||
libraryIndexFullResync: 'Resynchronisation complète',
|
||
libraryIndexDeltaSync: 'Synchronisation delta',
|
||
libraryIndexExcludeServer: 'Exclure de la synchronisation',
|
||
libraryIndexExcludingServer: 'Exclusion…',
|
||
libraryIndexExcludedTitle: 'Exclus de la synchronisation',
|
||
libraryIndexIncludeServer: 'Réinclure',
|
||
libraryIndexIncludingServer: 'Réinclusion…',
|
||
libraryIndexStatus: 'État',
|
||
libraryIndexStatusIdle: 'Inactif',
|
||
libraryIndexStatusProbing: 'Vérification du serveur…',
|
||
libraryIndexStatusInitial: 'Synchronisation initiale…',
|
||
libraryIndexStatusReady: 'Prêt ({{count}} morceaux)',
|
||
libraryIndexStatusError: 'Erreur — voir les journaux',
|
||
libraryIndexProgressIngest: '{{count}} morceaux indexés…',
|
||
libraryIndexProgressVerify: '{{checked}} vérifiés ({{deleted}} supprimés)',
|
||
libraryIndexSyncNow: 'Synchroniser maintenant',
|
||
libraryIndexVerify: 'Vérifier l’intégrité de la bibliothèque',
|
||
libraryIndexCancel: 'Annuler',
|
||
libraryIndexAutoReconcile: 'Réconciliation auto en cas de baisse du nombre',
|
||
libraryIndexAutoReconcileDesc: 'Recherche automatiquement les morceaux supprimés lorsque le serveur en signale moins que prévu.',
|
||
libraryIndexSyncError: 'Échec de la synchronisation de la bibliothèque : {{error}}',
|
||
libraryIndexBindError: 'Impossible d’activer l’index : {{error}}',
|
||
randomMixTitle: 'Liste noire du mix aléatoire',
|
||
luckyMixMenuTitle: 'Afficher Mix Chance dans le menu',
|
||
luckyMixMenuDesc: 'Active Mix Chance dans "Créer un mix" et comme entrée séparée quand la navigation est scindée. Visible uniquement si AudioMuse est actif sur le serveur courant.',
|
||
randomMixBlacklistTitle: 'Mots-clés de filtre personnalisés',
|
||
randomMixBlacklistDesc: 'Les morceaux sont exclus si un mot-clé correspond à leur genre, titre, album ou artiste (actif quand la case ci-dessus est cochée).',
|
||
randomMixBlacklistPlaceholder: 'Ajouter un mot-clé…',
|
||
randomMixBlacklistAdd: 'Ajouter',
|
||
randomMixBlacklistEmpty: 'Aucun mot-clé personnalisé ajouté.',
|
||
randomMixHardcodedTitle: 'Mots-clés intégrés (actifs quand la case est cochée)',
|
||
tabAudio: 'Audio',
|
||
tabStorage: 'Hors ligne & Cache',
|
||
tabAppearance: 'Apparence',
|
||
tabLibrary: 'Bibliothèque',
|
||
tabServers: 'Serveurs',
|
||
tabLyrics: 'Paroles',
|
||
tabPersonalisation: 'Personnalisation',
|
||
tabIntegrations: 'Intégrations',
|
||
inputKeybindingsTitle: 'Raccourcis clavier',
|
||
aboutContributorsCount_one: '{{count}} contribution',
|
||
aboutContributorsCount_other: '{{count}} contributions',
|
||
searchPlaceholder: 'Rechercher dans les paramètres…',
|
||
searchNoResults: 'Aucun réglage ne correspond à votre recherche.',
|
||
aboutMaintainersLabel: 'Mainteneurs',
|
||
integrationsPrivacyTitle: 'Avis de confidentialité',
|
||
integrationsPrivacyBody: 'Toutes les intégrations de cet onglet sont <strong>facultatives</strong> et, une fois activées, envoient des données à des services externes ou à votre serveur Navidrome. Last.fm reçoit votre historique d\'écoute, Discord affiche le morceau en cours dans votre profil, Bandsintown est interrogé par artiste pour récupérer les dates de tournée, et le partage « En cours de lecture » publie votre morceau actuel auprès des autres utilisateurs de votre serveur Navidrome. Si vous ne voulez rien de tout cela, laissez simplement la section correspondante désactivée.',
|
||
homeCustomizerTitle: 'Page d\'accueil',
|
||
queueToolbarTitle: 'Barre d\'outils de file d\'attente',
|
||
queueToolbarReset: 'Réinitialiser',
|
||
queueToolbarSeparator: 'Séparateur',
|
||
sidebarTitle: 'Barre latérale',
|
||
sidebarReset: 'Réinitialiser',
|
||
artistLayoutTitle: 'Sections de la page artiste',
|
||
artistLayoutDesc: 'Glissez pour réorganiser, basculez pour masquer des sections individuelles de la page artiste. Les sections sans données sont ignorées automatiquement.',
|
||
artistLayoutReset: 'Réinitialiser',
|
||
artistLayoutBio: 'Biographie de l\'artiste',
|
||
artistLayoutTopTracks: 'Titres populaires',
|
||
artistLayoutSimilar: 'Artistes similaires',
|
||
artistLayoutAlbums: 'Albums',
|
||
artistLayoutFeatured: 'Apparaît aussi sur',
|
||
playlistLayoutTitle: 'Mise en page de la playlist',
|
||
playlistLayoutDesc: 'Afficher ou masquer des éléments individuels sur la page de la playlist.',
|
||
playlistLayoutReset: 'Réinitialiser',
|
||
playerBarTitle: 'Barre de lecture',
|
||
playerBarReset: 'Réinitialiser',
|
||
playerBarStarRating: 'Note par étoiles',
|
||
playerBarFavorite: 'Favori (cœur)',
|
||
playerBarLastfmLove: 'Last.fm love',
|
||
playerBarPlaybackRate: 'Vitesse de lecture',
|
||
playerBarEqualizer: 'Égaliseur',
|
||
playerBarMiniPlayer: 'Mini-lecteur',
|
||
playbackRateTitle: 'Vitesse de lecture',
|
||
playbackRateEnabled: 'Activer la vitesse de lecture',
|
||
playbackRateEnabledDesc: 'Vitesse globale pour toutes les pistes. Non appliquée à la radio ni aux aperçus.',
|
||
playbackRateStrategy: 'Stratégie',
|
||
playbackRateStrategySpeed: 'Vitesse',
|
||
playbackRateStrategyVarispeed: 'Avec hauteur',
|
||
playbackRateStrategyPreserve: 'Hauteur',
|
||
playbackRateSpeed: 'Vitesse',
|
||
playbackRatePitch: 'Hauteur',
|
||
playbackRateDerivedPitch: 'Décalage de hauteur lié à la vitesse : {{value}}',
|
||
playbackRateAutoPitch: 'La hauteur est corrigée automatiquement.',
|
||
playbackRateHint: '« Vitesse » conserve la hauteur naturelle. « Avec hauteur » change la hauteur avec la vitesse. « Hauteur » ajoute un décalage manuel. Plus gourmand en CPU que « Avec hauteur ». Non pour la radio, les aperçus ou Orbit.',
|
||
playbackRateNeutral: 'À 1,0× sans décalage de hauteur, la lecture est normale.',
|
||
playbackRateOrbitPaused: 'Non appliqué pendant les sessions Orbit — la lecture reste à 1,0× pour la synchro.',
|
||
playbackRateOrbitPausedShort: 'Orbit : 1,0× pour la synchro.',
|
||
advancedMode: 'Avancé',
|
||
advancedModeTooltip: 'Afficher les options avancées dans tous les onglets des paramètres. Contributions de la communauté qui ne reflètent pas nécessairement la philosophie de conception des mainteneurs de Psysonic.',
|
||
advancedBadge: 'Avancé',
|
||
sidebarDrag: 'Glisser pour réorganiser',
|
||
sidebarFixed: 'Toujours visible',
|
||
randomNavSplitTitle: 'Diviser la navigation Mix',
|
||
randomNavSplitDesc: 'Afficher "Mix Aléatoire", "Albums Aléatoires" et "Mix Chance" comme entrées séparées dans la barre latérale plutôt que le hub "Créer un Mix".',
|
||
tabInput: 'Entrée',
|
||
tabUsers: 'Utilisateurs',
|
||
shortcutsReset: 'Réinitialiser',
|
||
shortcutListening: 'Appuyez sur une touche…',
|
||
shortcutUnbound: '—',
|
||
shortcutClear: 'Effacer',
|
||
globalShortcutsTitle: 'Raccourcis globaux',
|
||
globalShortcutsNote: 'Fonctionnent à l\'échelle du système, même quand Psysonic est en arrière-plan. Nécessite Ctrl, Alt ou Super comme modificateur.',
|
||
shortcutPlayPause: 'Lecture / Pause',
|
||
shortcutNext: 'Piste suivante',
|
||
shortcutPrev: 'Piste précédente',
|
||
shortcutVolumeUp: 'Volume +',
|
||
shortcutVolumeDown: 'Volume -',
|
||
shortcutSeekForward: 'Avancer de 10s',
|
||
shortcutSeekBackward: 'Reculer de 10s',
|
||
shortcutToggleQueue: 'Afficher/masquer la file',
|
||
shortcutOpenFolderBrowser: 'Ouvrir {{folderBrowser}}',
|
||
shortcutFullscreenPlayer: 'Lecteur plein écran',
|
||
shortcutNativeFullscreen: 'Plein écran natif',
|
||
shortcutOpenMiniPlayer: 'Ouvrir le mini-lecteur',
|
||
shortcutStartSearch: 'Lancer une recherche',
|
||
shortcutStartAdvancedSearch: 'Lancer une recherche avancée',
|
||
shortcutToggleSidebar: 'Afficher / masquer la barre latérale',
|
||
shortcutMuteSound: 'Couper le son',
|
||
shortcutToggleEqualizer: 'Ouvrir / basculer l\'égaliseur',
|
||
shortcutToggleRepeat: 'Basculer la répétition',
|
||
shortcutOpenNowPlaying: 'Ouvrir « En cours »',
|
||
shortcutShowLyrics: 'Afficher les paroles',
|
||
shortcutFavoriteCurrentTrack: 'Ajouter la piste actuelle aux favoris',
|
||
shortcutOpenHelp: 'Aide',
|
||
tabSystem: 'Système',
|
||
loggingTitle: 'Journalisation',
|
||
loggingModeDesc: 'Contrôle le niveau de verbosité des journaux backend dans le terminal.',
|
||
loggingModeOff: 'Désactivé',
|
||
loggingModeNormal: 'Normal',
|
||
loggingModeDebug: 'Débogage',
|
||
loggingExport: 'Exporter les journaux',
|
||
loggingExportSuccess: 'Journaux exportés ({{count}} lignes).',
|
||
loggingExportError: 'Impossible d\'exporter les journaux.',
|
||
ratingsSectionTitle: 'Notes',
|
||
ratingsSkipStarTitle: 'Passer pour 1 étoile',
|
||
ratingsSkipStarDesc:
|
||
"Après plusieurs sauts d’affilée, le morceau passe à 1 étoile. Uniquement s’il n’était pas encore noté.",
|
||
ratingsSkipStarThresholdLabel: 'Sauts',
|
||
ratingsMixFilterTitle: 'Filtrage par note',
|
||
ratingsMixFilterDesc:
|
||
"Filtrer le contenu peu noté dans {{mix}} et {{albums}}. Cliquer de nouveau sur l’étoile choisie désactive le seuil.",
|
||
ratingsMixMinSong: 'Morceaux',
|
||
ratingsMixMinAlbum: 'Albums',
|
||
ratingsMixMinArtist: 'Artistes',
|
||
ratingsMixMinThresholdAria: 'Étoiles minimum : {{label}}',
|
||
backupTitle: 'Sauvegarde & Restauration',
|
||
backupExport: 'Exporter les paramètres',
|
||
backupExportDesc: 'Enregistre tous les paramètres, profils serveur, configuration Last.fm, thème, EQ et raccourcis dans un fichier .psybkp. Les mots de passe sont stockés en clair — conservez le fichier en sécurité.',
|
||
backupImport: 'Importer les paramètres',
|
||
backupImportDesc: 'Restaure les paramètres depuis un fichier .psybkp. L\'application sera rechargée après l\'import.',
|
||
backupImportConfirm: 'Tous les paramètres actuels seront écrasés. Continuer ?',
|
||
backupSuccess: 'Sauvegarde enregistrée',
|
||
backupImportSuccess: 'Paramètres restaurés — rechargement…',
|
||
backupImportError: 'Fichier de sauvegarde invalide ou corrompu.',
|
||
playbackTitle: 'Lecture',
|
||
replayGain: 'Replay Gain',
|
||
replayGainDesc: 'Normaliser le volume des pistes avec les métadonnées ReplayGain',
|
||
replayGainMode: 'Mode',
|
||
replayGainAuto: 'Auto',
|
||
replayGainAutoDesc: 'Utilise le gain d\'album quand les pistes voisines de la file proviennent du même album, sinon le gain de piste.',
|
||
replayGainTrack: 'Piste',
|
||
replayGainAlbum: 'Album',
|
||
replayGainPreGain: 'Pré-Gain (fichiers taggés)',
|
||
replayGainPreGainDesc: 'Boost universel ajouté à chaque calcul ReplayGain. Utile si votre bibliothèque semble globalement trop discrète.',
|
||
replayGainFallback: 'Repli (sans tags / radio)',
|
||
replayGainFallbackDesc: 'Appliqué aux pistes (et flux radio) sans tags ReplayGain, pour que le contenu non taggé ne sorte pas plus fort que le reste.',
|
||
normalization: 'Normalisation',
|
||
normalizationDesc: 'Égalise la sonie perçue entre pistes, albums et radio.',
|
||
normalizationOff: 'Désactivé',
|
||
normalizationReplayGain: 'ReplayGain',
|
||
normalizationLufs: 'LUFS',
|
||
loudnessTargetLufs: 'LUFS cible',
|
||
loudnessTargetLufsDesc: 'Sonie de référence sur laquelle toutes les pistes sont calées. Valeur plus basse = sortie plus forte. Les services de streaming tournent autour de -14 LUFS.',
|
||
loudnessPreAnalysisAttenuation: 'Atténuation avant mesure',
|
||
loudnessPreAnalysisAttenuationDesc:
|
||
'Réduit le volume tant que la loudness du morceau n’est pas enregistrée. En streaming, des estimations grossières suivent, pas une mesure complète. 0 dB = rien ; plus négatif = plus discret. À droite, le dB effectif pour la cible actuelle.',
|
||
loudnessPreAnalysisAttenuationRef: 'Effectif {{eff}} dB avec cible {{tgt}} LUFS.',
|
||
loudnessPreAnalysisAttenuationReset: 'Valeur par défaut',
|
||
loudnessFirstPlayNote:
|
||
'À la première lecture d’un nouveau morceau, le volume peut brièvement varier pendant la mesure. La fois suivante, la mesure mise en cache prend le relais et tout reste stable. Les pistes à venir dans la file sont en général pré-analysées pendant la lecture précédente, ce cas est donc rare en pratique.',
|
||
crossfade: 'Fondu enchaîné',
|
||
crossfadeDesc: 'Fondu entre les pistes',
|
||
crossfadeSecs: '{{n}} s',
|
||
notWithGapless: 'Non disponible quand la lecture sans blanc est active',
|
||
notWithCrossfade: 'Non disponible quand le fondu enchaîné est actif',
|
||
gapless: 'Lecture sans blanc',
|
||
gaplessDesc: 'Préparer la piste suivante pour éliminer les silences entre les morceaux',
|
||
preservePlayNextOrder: "Préserver l'ordre « Lire ensuite »",
|
||
preservePlayNextOrderDesc: 'Les nouveaux éléments « Lire ensuite » s\'ajoutent à la fin de la file existante au lieu de la doubler.',
|
||
trackPreviewsTitle: 'Aperçus de pistes',
|
||
trackPreviewsToggle: 'Activer les aperçus de pistes',
|
||
trackPreviewsDesc: 'Affiche les boutons Lecture et Aperçu dans les listes pour un court extrait au milieu du morceau.',
|
||
trackPreviewStart: 'Position de départ',
|
||
trackPreviewStartDesc: 'À quel point du morceau l\'aperçu commence (% de la durée).',
|
||
trackPreviewDuration: 'Durée',
|
||
trackPreviewDurationDesc: 'Combien de temps chaque aperçu joue avant de s\'arrêter.',
|
||
trackPreviewDurationSecs: '{{n}} s',
|
||
trackPreviewLocationsTitle: 'Où afficher les aperçus',
|
||
trackPreviewLocationsDesc: 'Choisissez dans quelles listes afficher les boutons d\'aperçu.',
|
||
trackPreviewLocation_suggestions: 'Dans les suggestions de playlist',
|
||
trackPreviewLocation_albums: 'Dans les listes d\'albums',
|
||
trackPreviewLocation_playlists: 'Dans les playlists',
|
||
trackPreviewLocation_favorites: 'Dans les favoris',
|
||
trackPreviewLocation_artist: 'Dans les meilleurs morceaux de l\'artiste',
|
||
trackPreviewLocation_randomMix: 'Dans Random Mix',
|
||
preloadMode: 'Précharger la piste suivante',
|
||
preloadModeDesc: 'Quand commencer à mettre en mémoire tampon la piste suivante',
|
||
nextTrackBufferingTitle: 'Mise en mémoire tampon',
|
||
preloadHotCacheMutualExclusive: "Preload et Hot Cache remplissent le même rôle — un seul peut être actif à la fois. Activer l'un désactive automatiquement l'autre.",
|
||
preloadOff: 'Désactivé',
|
||
preloadBalanced: 'Équilibré (30 s avant la fin)',
|
||
preloadEarly: 'Tôt (après 5 s de lecture)',
|
||
preloadCustom: 'Personnalisé',
|
||
preloadCustomSeconds: 'Secondes avant la fin : {{n}}',
|
||
infiniteQueue: 'File infinie',
|
||
infiniteQueueDesc: 'Ajouter automatiquement des morceaux aléatoires quand la file est épuisée',
|
||
experimental: 'Expérimental',
|
||
fsPlayerSection: 'Lecteur plein écran',
|
||
fsShowArtistPortrait: "Afficher la photo de l'artiste",
|
||
fsShowArtistPortraitDesc: "Afficher la photo de l'artiste (ou la pochette) sur le côté droit du lecteur plein écran.",
|
||
fsPortraitDim: "Assombrissement de la photo",
|
||
fsLyricsStyle: "Style des paroles",
|
||
fsLyricsStyleRail: "Rail",
|
||
fsLyricsStyleRailDesc: "Rail glissant classique de 5 lignes.",
|
||
fsLyricsStyleApple: "Défilement",
|
||
fsLyricsStyleAppleDesc: "Liste déroulante plein écran.",
|
||
sidebarLyricsStyle: "Style de défilement des paroles",
|
||
sidebarLyricsStyleClassic: "Classique",
|
||
sidebarLyricsStyleClassicDesc: "La ligne active est centrée.",
|
||
sidebarLyricsStyleApple: "Apple Music-like",
|
||
sidebarLyricsStyleAppleDesc: "La ligne active reste en haut avec une animation fluide.",
|
||
seekbarStyle: 'Style de la barre de lecture',
|
||
seekbarStyleDesc: 'Choisir l\'apparence de la barre de progression',
|
||
seekbarTruewave: 'Forme d\'onde réelle',
|
||
seekbarPseudowave: 'Forme d\'onde pseudo',
|
||
seekbarLinedot: 'Ligne & point',
|
||
seekbarBar: 'Barre',
|
||
seekbarThick: 'Barre épaisse',
|
||
seekbarSegmented: 'Segmentée',
|
||
seekbarNeon: 'Néon',
|
||
seekbarPulsewave: 'Onde pulsée',
|
||
seekbarParticletrail: 'Traînée de particules',
|
||
seekbarLiquidfill: 'Tube liquide',
|
||
seekbarRetrotape: 'Bande rétro',
|
||
themeSchedulerTitle: 'Planificateur de thème',
|
||
themeSchedulerEnable: 'Activer le planificateur de thème',
|
||
themeSchedulerEnableSub: 'Bascule automatiquement entre deux thèmes selon l\'heure',
|
||
themeSchedulerDayTheme: 'Thème de jour',
|
||
themeSchedulerDayStart: 'Début du jour',
|
||
themeSchedulerNightTheme: 'Thème de nuit',
|
||
themeSchedulerNightStart: 'Début de la nuit',
|
||
themeSchedulerActiveHint: 'Le planificateur de thème est actif - les thèmes changent automatiquement.',
|
||
visualOptionsTitle: 'Options Visuelles',
|
||
coverArtBackground: "Fond d'Art de Poche",
|
||
coverArtBackgroundSub: "Afficher la pochette floutée comme fond dans les en-têtes d'albums et de playlists",
|
||
playlistCoverPhoto: 'Photo de Couverture de Playlist',
|
||
playlistCoverPhotoSub: 'Afficher la grille de photos de couverture dans la vue détaillée des playlists',
|
||
showBitrate: 'Afficher le Débit',
|
||
showBitrateSub: 'Afficher le débit audio dans les listes de pistes',
|
||
floatingPlayerBar: 'Barre de Lecteur Flottante',
|
||
floatingPlayerBarSub: 'Garder la barre du lecteur flottante au-dessus du contenu',
|
||
uiScaleTitle: "Mise à l'échelle de l'interface",
|
||
uiScaleLabel: 'Zoom',
|
||
confirmDeleteServerLibrary: 'Supprimer aussi l’index local de bibliothèque de ce serveur ? Cliquez sur Annuler pour conserver la copie en cache pour un usage hors ligne.',
|
||
waveformCacheClearBtn: 'Vider le cache des formes d’onde',
|
||
waveformCacheCleared: 'Cache des formes d’onde vidé ({{count}} lignes).',
|
||
waveformCacheClearFailed: 'Impossible de vider le cache des formes d’onde.',
|
||
useCustomTitlebar: 'Barre de titre personnalisée',
|
||
useCustomTitlebarDesc: 'Remplace la barre de titre système par une barre intégrée assortie au thème de l’app. Désactivez pour utiliser la barre GNOME/GTK native.',
|
||
analyticsStrategyTitle: 'Stratégies d’analyse',
|
||
analyticsStrategyDesc: 'Choisissez le style d’analyse pour la bibliothèque.',
|
||
analyticsStrategyLabel: 'Stratégie',
|
||
analyticsStrategyLazy: 'Paresseuse',
|
||
analyticsStrategyLazyDesc: 'Analyse uniquement quand les pistes sont lues ou entrent dans le cache hot/hors ligne — utilisation minimale du CPU et du réseau.',
|
||
analyticsStrategyAdvanced: 'Agressive',
|
||
analyticsStrategyAdvancedDesc: 'Analyse de fond plus agressive. Une fois terminée, vous obtenez le BPM pour toutes les pistes et un chargement immédiat de loudness et de formes d’onde.',
|
||
analyticsStrategyPriorityTitle: 'Priorité d’analyse (toujours appliquée)',
|
||
analyticsStrategyPriorityHigh: '1 — En cours de lecture : télécharger et analyser en premier (octets de lecture, backfill loudness ou HTTP si nécessaire).',
|
||
analyticsStrategyPriorityMiddle: '2 — À suivre : les ~5 pistes suivantes de la file, préchargement de la suivante et voisines du hot-cache — analyse depuis cache/téléchargements si possible, backfill HTTP seulement en cas d’absence.',
|
||
analyticsStrategyPriorityLow: '3 — Lot bibliothèque (Agressive uniquement) : file d’arrière-plan automatique en fin de file ; réalimentée par watermark (~3× workers) sans attendre une file vide.',
|
||
analyticsStrategyServerLabel: 'Server',
|
||
analyticsStrategyProgressLabel: 'Progression de l’analyse :',
|
||
analyticsStrategyProgressValue: '{{percent}}% ({{done}}/{{total}})',
|
||
analyticsStrategyActionsLabel: 'Actions',
|
||
analyticsStrategyParallelismLabel: 'Workers parallèles',
|
||
analyticsStrategyParallelismValue: '{{n}} threads',
|
||
analyticsStrategyParallelismDesc: 'Nombre de pistes à télécharger et analyser en même temps (HTTP + CPU). Des valeurs plus élevées accélèrent le rattrapage de la bibliothèque, mais consomment plus de réseau et de CPU.',
|
||
analyticsStrategyAdvancedWarning: 'Le mode agressif utilise davantage de CPU et de bande passante réseau pendant l’exécution du lot bibliothèque en arrière-plan.',
|
||
analyticsStrategyServerRemoved: 'Serveur supprimé',
|
||
analyticsStrategyClearAction: 'Effacer l’analyse',
|
||
analyticsStrategyClearTitle: 'Effacer l’analyse ?',
|
||
analyticsStrategyClearDesc: 'Effacer l’analyse de {{server}} supprime les formes d’onde et données de loudness mises en cache. Réajouter ce serveur plus tard peut nécessiter une longue réindexation.',
|
||
analyticsStrategyClearCancel: 'Annuler',
|
||
analyticsStrategyClearConfirm: 'Effacer l’analyse',
|
||
analyticsStrategyClearSuccess: 'Analyse effacée pour le serveur supprimé.',
|
||
analyticsStrategyClearError: 'Échec de l’effacement de l’analyse pour le serveur supprimé.',
|
||
analyticsStrategyProgressEmptyAfterFailed: '100% (0/0, bloqué par des pistes en échec)',
|
||
analyticsFailedTracksOpenTitle: 'Pistes en échec : {{count}}',
|
||
analyticsFailedTracksTitle: 'Pistes d’analyse en échec — {{server}}',
|
||
analyticsFailedTracksDesc: 'Ces pistes ont échoué de manière répétée au décodage/enrichissement et sont exclues de l’analyse de fond automatique.',
|
||
analyticsFailedTracksLoading: 'Chargement de la liste des pistes en échec…',
|
||
analyticsFailedTracksEmpty: 'Aucune piste en échec pour ce serveur.',
|
||
analyticsFailedTracksClose: 'Fermer',
|
||
analyticsFailedTracksExport: 'Exporter la liste',
|
||
analyticsFailedTracksExportSuccess: 'Liste des pistes en échec exportée ({{count}}).',
|
||
analyticsFailedTracksExportError: 'Impossible d’exporter la liste des pistes en échec.',
|
||
analyticsFailedTracksRescan: 'Relancer l’analyse des pistes en échec',
|
||
analyticsFailedTracksRescanSuccess: 'Relance programmée pour {{count}} pistes en échec.',
|
||
analyticsFailedTracksRescanError: 'Impossible de relancer l’analyse des pistes en échec.',
|
||
analyticsFailedTracksLoadError: 'Impossible de charger les pistes en échec.',
|
||
backupImportAny: 'Importer une sauvegarde',
|
||
backupImportAnyConfirm: 'Importer le fichier de sauvegarde sélectionné et appliquer son contenu (réglages, bases de données de bibliothèque ou sauvegarde complète). Continuer ?',
|
||
backupModeFull: 'Complet',
|
||
backupModeLibrary: 'Bases de données de bibliothèque',
|
||
backupModeConfig: 'Configuration',
|
||
backupFullDesc: 'Archive les réglages et les bases de données de bibliothèque dans un seul fichier de sauvegarde.',
|
||
backupFullExport: 'Exporter une sauvegarde complète',
|
||
backupFullImport: 'Importer une sauvegarde complète',
|
||
backupFullImportConfirm: 'Cela écrasera les réglages, remplacera les bases de données actuelles et les déplacera en .bak. Continuer ?',
|
||
backupFullExportSuccess: 'Sauvegarde complète exportée.',
|
||
backupFullImportSuccess: 'Sauvegarde complète importée — rechargement…',
|
||
backupFullImportError: 'Impossible d’importer la sauvegarde complète.',
|
||
backupLibraryExport: 'Exporter les bases de données',
|
||
backupLibraryExportDesc: 'Crée une archive compressée contenant des instantanés SQLite propres des bases de données de bibliothèque.',
|
||
backupLibraryImport: 'Importer les bases de données',
|
||
backupLibraryImportDesc: 'Restaure les bases de données de bibliothèque depuis un fichier d’archive. Les bases actuelles sont déplacées en .bak avant le basculement.',
|
||
backupLibraryImportConfirm: 'Cela remplacera les bases de données actuelles et les déplacera en .bak. Continuer ?',
|
||
backupLibraryExportSuccess: 'Sauvegarde des bases de données exportée.',
|
||
backupLibraryImportSuccess: 'Sauvegarde des bases de données importée.',
|
||
backupLibraryImportError: 'Impossible d’importer la sauvegarde des bases de données.',
|
||
backupOverlayExportTitle: 'Création de la sauvegarde…',
|
||
backupOverlayImportTitle: 'Restauration de la sauvegarde…',
|
||
backupOverlayHint: 'Vous pouvez garder la fenêtre ouverte pendant le traitement des fichiers. La saisie est temporairement verrouillée.',
|
||
};
|