This describes the adapter in scripts/. The app uses it for Inspect, QueryAccounts, ManageAccount, Register, the
mod and backup operations, PrepareClient, Dependencies, Build, ReloadData, ImportSaves and FreshSaves. Starts, stops and
branch switches go through live.ps1 and git from the app (launcher.md); the adapter's own Start, Play,
Stop, Restart, CloseGame, Switch and capture actions remain, with their tests, but the app does not call them.
RuntimeSnapshot.Capture is optional and separate from Services: it never affects normal server readiness.
LauncherSettings.CaptureAreaLayouts defaults false. CheckCapture, SetupCapture, StartCapture and
StopCapture use the same runtime writer lock as other mutations. Inspection never attaches to a client.
No LocalExile source changes or launcher-specific server endpoint are required. A checkout supports capture when it has
scripts/walkmaps/walkmaps.py and walkmaps.js, and an AreaLayouts.cs naming Game_WALKMAPS in
src/GameServer.Gateway/World/ (since 2026-10-31) or in src/GameServer.Gateway/ (before). The app's walk maps are the Control
section's Walk maps switch (live.ps1 -Walkmaps).
The desktop owns one normal workspace per Windows user/logon session, independent of executable name, branding or installation folder. Core supplies a kernel mutex lifetime and a bounded, same-user/session named-pipe activation protocol. Ownership is held on a dedicated thread so async startup/disposal cannot release a mutex on the wrong thread. Process exit/crash releases kernel ownership; no persistent marker file controls startup. Clients can retain a disconnected pipe handle after a crash, including its original server PID in Windows. The stable discovery pipe advertises an unpredictable endpoint for this owner; new clients verify the matching greeting and OS server PID there before sending an activation or allowing foreground focus. The stable pipe also accepts older clients, and new clients still authenticate older owners that do not advertise a private endpoint. Both endpoints close before ownership is released. The mutex admits one owner, and that owner may start coordination only once.
Activation carries only build identity and an optional normalized checkout path. It cannot execute runtime actions, save preferences or change the active checkout. The owner reports focus, build/checkout conflict, starting or closing, plus its current checkout and busy state. Named pipes require the current user/elevation level and verify peer process IDs; packets and connection lifetimes are bounded. Unreachable owners fail closed. A later launch may claim ownership only after the original owner releases it. Build identity is the version plus the executable's size and time.
This UI gate does not replace Local\EmulatorWorkspaceLauncher.Runtime.v1. That existing operation lock still
serializes changes when a developer explicitly uses --allow-multiple or an older launcher is present. The override
is a visible testing mode, not separate settings/save isolation. Legacy detection is best effort for the known/current
executable names, verifying the same user/session, executable metadata, branding and managed assembly identity without
loading code. Old builds launched after a newer app cannot be forced to participate; no processes are auto-terminated.
QueryAccounts returns an optional typed AccountData inventory and never initializes/migrates storage. Browsing uses
one read-only SQLite snapshot; it exposes names, IDs, character summaries and opaque revision tokens, never credential
verifiers. A snapshot's AccountWriteBlockedReason explains runtime blockers, including the account service.
ManageAccount accepts a reviewed AccountDataRequest on UTF-8 stdin. Its required ExpectedDatabase must match
the selected profile's resolved database before backup or mutation; desktop registration requests carry the same
binding. A profile/location change while a dialog is open requires another review. It shares the global runtime writer mutex,
requires stopped/known runtime inventory, makes the configured automatic save backup and checks inventory again.
AccountBridge.ps1 invokes AccountData.py through a UTF-8 stdin pipe, without transcribing passwords. The helper
checks known tables/fields/import state (a split layout opens characters.db with auth.db attached as auth, as the
servers do, and knows both files' tables, updates included), starts an immediate transaction, rechecks the selected account revision,
validates names/destinations and commits all related row changes together (across the two split files, each commits
on its own: the backup before covers both). Unknown layouts are read-only or rejected.
Password/copy operations additionally recognize the selected checkout's verifier format. LocalExile source and DLLs
remain independent of the distributable launcher. Registration retains the upstream temporary-service workflow and
now follows the same backup and account runtime gates.
Every account mutation is offline, including create, rename and password changes. Auth character selection, Gateway, watchers between restarts, other installations, a game client, account-service executables and port 7000 can block it. No forced shutdown is added. SQLite locks/transactions and revision checks cover competing data writers; manual runtime starts outside Waypoint must wait until an offline edit finishes. Browsing remains available while services run. Account reads/writes require Python's SQLite 3.37+ support. Tests use disposable data, including an upstream Storage/Core harness. No real player account or save is used for mutation validation.
The launcher owns its settings and UI. LocalExile owns preparation, extraction, build semantics, client launch, account/storage formats and game behavior. The repositories are independent; no server source changes are required.
The Windows map viewer embeds its own helper source in Waypoint. Under the checkout operation lock it builds the selected checkout's existing GameServer.Data project and the helper into a private directory under Waypoint's data folder, with restore/intermediate outputs there too. Only the isolated helper references those built assemblies; the desktop has no server project dependency. It reads the existing game pack, tables and seed baseline and exposes map data on loopback. The viewer ends its helper process and removes its private build on close. It does not start gameplay servers or the client, write game data or saves, or require LocalExile's map-service hook. Generator API compatibility belongs to Waypoint's helper.
Launcher.Core.RuntimeClient starts RuntimeBridge.ps1 with structured ProcessStartInfo.ArgumentList arguments.
No command is assembled from user text for a shell. The upstream script does assemble cmd strings, so the adapter
refuses checkout paths containing cmd metacharacters; ordinary spaces are supported.
Core actions include Inspect, Build, Start, Play, Stop, Restart, CloseGame, PrepareClient, Dependencies, Register,
QueryAccounts and ManageAccount, plus the source/mod/backup actions described below.
Service selection: All, Auth, Patch, Gateway.
Each invocation writes a JSON result containing Ok, Message, and a typed snapshot. Mutation operations also write
a local transcript except Register and ManageAccount. Failures include FailedStage. Mutations replace a progress.json containing
the current named stage, detail and log path. Core also interprets upstream extraction messages into named subtasks.
Elapsed time is measured locally; no estimated percentage or remaining time is fabricated.
Read-only inspection never creates data/log directories inside the source checkout.
The helper receives no redirected stdout/stderr. Register and ManageAccount receive JSON requests through redirected UTF-8 stdin; neither invokes live.ps1. This preserves live.ps1's no-pipeline requirement. A Windows named mutex serializes mutations across all launcher instances and checkouts, since this adapter uses fixed ports. The desktop also serializes refresh/operations and waits for an active operation to finish before it closes. The Core API's cancellation token only cancels read-only waiting, not an in-progress runtime mutation.
Repository discovery is a separate read-only Core capability. It queries the public upstream's advertised default branch HEAD and compares actual local Git HEADs; it does not fetch, update branches or require GitHub authentication. Only a sole verified match from a completed first-run lookup can populate an untouched selection automatically. Saved/manual choices take priority; manual browsing is available before, during and after lookup. Candidate detection does not imply setup/runtime readiness. See repository discovery for bounds and validation.
Game_* variables inherited from the launcher host are cleared in the child process.
When the local wrapper is enabled and exists, inspect config/runtime.local.ps1 as an AST, accepting only literal
Game_* string assignments. Do not execute configuration while inspecting. Complex profiles fail with an explanation.
Literal profile environment settings apply to server commands. Game launch uses scripts/dev/live.local.ps1
when enabled, which ultimately calls the supported live.ps1.
Existing-profile databases must exist; never silently fall back to a new empty database.
Only standard local listener, client and archive paths are supported. Custom TLS/CDN settings fail preflight.
Normal upstream operation uses data/saves.db; local-profile operation uses the profile's explicit existing database.
A LocalExile with sql/base/characters/ (a checkout or a release from LocalExile/LocalExile#758 on) splits it: accounts in
data/auth.db and the rest in data/characters.db (Game_AUTH_DB, Game_CHARACTERS_DB; without Game_AUTH_DB, auth.db
beside a characters.db, else <name>-auth.db, as SaveDatabase.AuthPathFor does). The snapshot's SaveDatabase is then
characters.db and AuthDatabase its auth.db. Its first server start migrates an old data/saves.db; until then that file is
the saves, and the snapshot names it EarlierSaveDatabase (only for the default characters.db, the one the servers migrate).
All production game-data paths remain relative to the selected checkout.
Accept a server as owned only when:
- It is dotnet with exactly the expected Debug assembly argument (+
servefor Auth). - Its live parent is a dedicated cmd created no later than the server, with the exact upstream command and both absolute per-checkout log destinations. Trailing Windows command-line whitespace is ignored.
- Its PID owns every required listening port before the status becomes Ready.
Do not adopt unrelated absolute build folders, identical relative DLL paths in another checkout, shared terminal
sessions or orphaned relative commands. Conflicting listeners block start/play; failed inventory queries fail closed.
A conflict names the program holding the port. When that program is no LocalExile server or watcher (Steam's helper on
8080, say), the snapshot also lists it in PortsInUse: it still blocks start/play, but not a change of mods, modules,
leagues or accounts, since it holds none of their files. A listener whose process Waypoint cannot name blocks everything.
This is a compatibility/ownership guard, not an isolation boundary against malicious same-user code forging command lines.
Gateway may instead be a verified dotnet watch run --project src\GameServer.Gateway --non-interactive -- root,
with the same dedicated cmd and absolute checkout log destinations. Its app executable must have the exact Debug
path and a live, timestamp-ordered ancestry to that root. Watch ownership persists during child restart/build gaps;
such a service is Starting, not Stopped. Foreign matching server/watcher processes also block launch, even when they
do not hold a port, because upstream launch scripts may otherwise terminate them by name.
Graceful shutdown runs ConsoleSignal.ps1, which rechecks PID, parent and creation timestamp. It attaches only to
the verified dedicated console. Every console peer must be the cmd, signal helper or a verified descendant of that
server/watch root. Unknown peers fail closed. It sends Ctrl+C, then exits. The adapter waits up to 20 seconds for the
captured server/watch subtree to exit and reports failure without forcing termination.
The game is closed by its window and checked process identity; service shutdown requires the game to be closed first.
Start runs the upstream extraction script (with -Servers when the script declares it, as live.ps1 does), builds missing selected services when no owned services are running,
then starts only verified missing services using upstream's standard Debug commands, root working directory,
dedicated cmd consoles and checkout-specific logs. It sets the upstream Gateway-enter, packet-dump, watch-log
and disabled-walkmaps environment defaults. Old logs for those services are archived without touching live services.
The launcher does not invoke live.ps1's broad name/port cleanup, which force-terminates matching processes across
checkouts. It never needs that cleanup to start a missing service. Normal and watched startup share the same ownership
and graceful-stop checks. Upstream extraction and the game/client-only launch workflow remain unchanged.
Starting another service
beside live services reuses existing binaries only when the selected source commit matches and tracked source is clean.
Before starting a missing Gateway, the adapter incrementally builds every Mods/Source/**/*.csproj, matching
upstream's mod preparation. Revisions without that folder require no extra step. A failed mod build blocks the
requested service launch before any missing service is started; existing services remain running. The named
Building mods stage retains the compiler output. Beside live services, mod builds use --no-dependencies to avoid
overwriting shared server assemblies; missing dependencies require stopping services and building the checkout.
The adapter does not edit mod manifests, mod-state.txt, binary-only mods or enable/disable preferences.
The 0.3.1 startup fix alone does not reconcile stale mod folders or provide live management; the 0.4.0 extension below does.
Stop all services and Build checkout after changing source. V1 does not attest all untracked/ignored build inputs.
The Versions section shows source and disk-binary identities separately; it is not a full immutable running-build manifest.
Failed/partial startup stays visible for diagnosis; it does not silently tear down processes that did successfully start.
Upstream 5fc27fa also has a scalar-array Auth argument join ($command + $serverArgs[$s]) that generates Auth.dllserve.
The explicit standard service commands preserve the intended Auth argument boundary. No LocalExile file is patched.
Game launch is two steps: start/wait for required servers, then live.ps1 -ClientOnly. Running is distinct from a native menu being ready, a successful authentication or entry into a playable area.
Setup writes require the selected installation's game/services to be stopped and no listener conflicts.
PrepareClient never changes a client reached through a link: a linked client that is ready needs nothing, and one that is
not is refused, because other checkouts may share it and its patched executable trusts one set of keys. On a client in the
checkout it refuses redirected files, retains existing keys/prepared executable, refuses an unpaired prepared executable
before writing, and uses the checkout's Auth and Patch commands for missing key/executable preparation and the copied
archive's gateway list. Users supply the complete client copy.
Dependencies runs npm ci --ignore-scripts --no-audit --no-fund in Tools/ooz with the checkout's lockfile.
Register builds the checkout's Host service, starts a dedicated temporary localhost:7000 console with operation-local logs, verifies its process and listener, sends the upstream JSON-lines registration request, and shuts it down with the same verified graceful console mechanism on success or failure. It refuses an occupied port and nonstandard Host bind/port configuration. Credentials never enter command arguments, a request file or a transcript. Registration does not perform native login or character creation, change existing passwords, or retain a retry request.
Log reads use fixed service/game filenames and bounded tails. Search and warning/error filtering are local. Diagnostic reports include limited operation/selected-log lines and structural metadata; no recursive file collection. Redaction covers common labelled credentials, long hex values, home/installation paths, email addresses and detected or explicitly supplied names. Validated public source/build identifiers are retained separately. The user reviews the preview and explicitly copies it; arbitrary private details can still require manual review. No upload exists.
Prefer an explicit versioned LocalExile control interface with runtime IDs, actual loaded build identity, working directory, readiness and save-safe shutdown. Keep v1 assumptions isolated here so the UI need not change with that interface. Immutable environment manifests, separate source/build paths, release builds and metrics sessions remain separate capabilities.
Core queries local refs with read-only Git and public upstream PR metadata with bounded unauthenticated GitHub GETs,
conditional ETags and a two-minute cache. Local refs are usable before GitHub finishes. Fetch/activation/backup/restore
run under the existing global runtime mutation mutex. Git uses argument boundaries, no prompts, disabled hooks for
launcher mutations, and no force checkout/reset/clean/stash. PR fetch refs are positive integers under refs/launcher/pr/;
PR/remote activation detaches at a verified full commit. Local branches use normal switch. Target source must contain
the supported solution, Gateway and launch markers. Tracked runtime-profile changes are refused.
Activation rejects tracked edits and untracked source (ignored runtime files are reused), requires the game closed, stops owned
services, backs up saves by default, switches source and builds. It does not automatically start afterward. Build failure
preserves saves and leaves explicit selected source/stopped services. This is not an atomic hot branch replacement.
Hot reload launch preference is passed as -NoHotReload only where supported. Gateway's explicit log confirmations
drive pending/applied/failed status; a successful build is not proof of application. Watcher health and child presence
remain separate from historical log events. Auth/Patch, static initializers and extracted data have no generic reload guarantee.
Save backups use Python's SQLite online backup API, including committed WAL pages, then PRAGMA integrity_check.
A split layout's characters.db and auth.db are copied in one read transaction, so one backup holds the same moment of
both; until its servers migrate it, the old saves.db is backed up as it is. Copies are left in rollback-journal mode, one
file each. They are keyed by canonical database path under the launcher's stable local data directory; a default
characters.db keeps the key of the data/saves.db it came from, so earlier backups stay listed. Metadata records source
commit/branch at backup, requested source/fresh choice, time, and last Gateway build recorded at a successful launcher
start. That build hash is not an attestation of later hot edits or external launches. Unknown history remains unknown.
Automatic backups default on for current/fresh activation, build, Gateway startup/restart, data reload and restore;
users may disable them in either relevant UI page. Manual backup bypasses that preference, and so does ImportSaves,
which replaces every character of the target: its saves are always backed up first. ImportSaves also copies the
source folder's mod-state.txt into a source checkout, and leaves a release's own as it is. No backup occurs per
externally saved edit or watcher-triggered restart. Backup failure blocks the subsequent requested change.
Restore validates the chosen backup and its save-store association, requires stopped owned runtime, backs up current
saves when enabled, and replaces only saves. Fresh saves are created only after successful build. Replaced SQLite
database/WAL/SHM files are moved to operation-local recovery even with automatic copying off. Redirected save/backup
paths are refused. A split backup restores both files; a saves.db backup into a split layout goes back as
data/saves.db (its databases set aside) for the servers to migrate; an older LocalExile refuses a split backup or
another installation's split saves. Deletion accepts only a validated backup ID in the selected store and its known files; no broad
recursive deletion occurs. Client, keys, source and game-data overrides are outside a save snapshot.
Explicit game-data reload uses upstream's optional native client helper for the owned client and ready Gateway: it sends
/reload to a split layout (world.db) and /game_data reload before it. Only that disposable helper has captured streams
(never live.ps1). The adapter waits for Game data reloaded: revision N
in the helper's new Gateway replies. A timeout, missing dependency or missing confirmation reports failure/uncertainty;
the launcher never assumes submission means application. The helper never starts a game for this operation.
The typed snapshot includes optional mod capability, effective folder/global enable preference and a bounded cached
runtime list. Older snapshots/branches remain valid. A source checkout has a mod host when it has
src/GameServer.Modding/GameServer.Modding.csproj and Program.Mods.cs in src/GameServer.Gateway/Modding/ (since
2026-10-31) or in src/GameServer.Gateway/ (before). Core reads JSONC manifests and native saved choices without
loading assemblies. Source projects follow the documented Mods/Source//.csproj convention.
BuildMod, BuildMods, InstallMod, UninstallMod, SaveModSettings, EnableMod, DisableMod, ReloadMod, QueryMods and RestoreModChoices use the same named mutation mutex and process-ownership/conflict checks. Source builds target only physical csproj paths inside Mods/Source, reuse dependencies beside running servers, and preserve compiler failures. Mod IDs are bounded single command tokens. A stopped Gateway permits atomic state-file replacement; a running Gateway requires native commands. The helper receives JSON lines over stdin and captured output, never starts a client and can be terminated on timeout without killing the client/server. Acknowledgement alone is insufficient: /mod must confirm the selected outcome. Timeout/no-reply errors state that a submitted command may already have applied.
Runtime reports are tied to Gateway PID/start time and a binary/manifest/state-file metadata stamp, expire after 120 seconds, and are labelled last checked. Regular inspection never attaches to a client. Check live status explicitly requests /mod. This external contract cannot attest arbitrary mod writes, forged replies from executable mods or all runtime state; it avoids claiming otherwise.
Mod-changing operations use the existing default-on backup preference. Metadata embeds saved choices, manifests, DLL SHA-256 hashes and confirmed runtime history, within a 4 MB limit. This adds no files to backup folders, so the two-file deletion contract remains intact. RestoreModChoices validates the save association and recorded mod folder, requires Gateway stopped, and replaces only native enable overrides after the optional current-save backup.
Standard first-party builds record only their manifest, primary DLL and PDB hashes in a per-checkout launcher registry. After their source project disappears, unchanged recorded files are moved individually into new physical local recovery folders before a stopped Gateway starts or after source activation. Changed files block preparation. No recursive mod-folder deletion or third-party adoption exists. Unrecorded outputs and custom conventions remain user-managed; an unchanged project path is not an attestation of third-party compatibility. Untracked Mods/Binaries files are treated as runtime data even on older revisions lacking the ignore rule; tracked edits anywhere and other untracked source still block activation. No repository ignore file is changed.
InstallMod copies a folder staged by Core (only under Waypoint's mod-downloads folder, using native separators and
case-sensitive containment on Linux) into Mods/Binaries/<id>
(-ModTarget Binaries: a release or script mod) or Mods/Source/<id> (Source: a project, not built: the player's
BuildMod or live.ps1 builds it; refused on release installs). Under the mutex and after the optional backup, an existing copy, and
Mods/Source/<id> when installing a binary, is moved to Mods/.replaced/<stamp>/ and its managed-registry entry
dropped. UninstallMod moves Mods/Binaries/<id> (and Mods/Source/<id> in a checkout) the same way, drops the
registry entry and the mod's line of mod-state.txt. A batch passes -ModIds a;b (all checked first, one backup):
InstallMod adds -ModStageds and -ModTargets in the same order, and BuildMod's -ModProjects a;b builds several in one
parallel MSBuild run over a temporary traversal project. SaveModSettings atomically writes data/mods/<id>.json from
validated values. Core reads settings.json and the user file itself; script mods are fingerprinted by their scripts'
hashes. The one checkout write outside the adapter is the on/off switch: Core replaces mod-state.txt atomically
(ModCatalog.WriteChoice) while holding Shared's workspace lock, so a switch is instant; EnableMod and DisableMod remain
for other callers. A running server with no verified source hook gets a restart notice in both interfaces; releases are
unknown because they have no source. Saved choices are not proof of a runtime load.
Workspace operations return null only for lock contention. Declined preparation returns a non-success Cancelled result,
without raising the failure dialog. The mod queue completes that job rather than retrying the preparation prompt.
Flag artwork is optional inspection, separate from configuration mutations. LeagueArt.py invokes only a verified,
already-built PoEDataExtractor cat command with explicit output files in Waypoint's cache. It never builds a project,
installs a dependency, starts a game/server, or writes a GGPK. The supported source presentation contract supplies a
constant LeagueFlag selector and generic family; unknown implementations are refused rather than inferred from names.
The flag table, atlas key and inclusive texture rectangle determine the actual image, including native fallback for custom
leagues. A source/archive identity check precedes cache publication, and hashes verify cached previews. Personal frame
colours live solely in Waypoint's settings, scoped by checkout and flag; they never enter the adapter's write requests.
Content in an inspection names the selected profile's Game_MODULES_FOLDER, Game_LEAGUES_FOLDER and
Game_LEAGUE_MODULES paths (default Modules, Leagues and data/league-modules.json). CanEditSettings requires the source
shared settings hook, CanChoose the source league-override hook, and CanCreate the source league loader for creation and
visibility editing. A release has no source to inspect, so its version decides: from v0.2.0-beta on (the releases whose
servers read data/league-modules.json, data/modules/ and data/leagues/ from the release's own folder) it has
CanChoose, CanEditSettings and CanCreate, and an older release, or one with no readable version, has none. A release
ships its leagues as source with the compiler that builds them, and an update writes only its zip's files, so a new
league's folder stays. ShippedLeaguesFixed is true on a release: the leagues it came with are its own files, which an
update writes over, so SetLeagueVisibility there takes only a league with a .waypoint-league.json. LeagueData.py runs
under a release's bundled Python, the embeddable one, which does not look for modules beside a script: it adds its own
folder to the module path before it imports AccountData. InstallMod, UninstallMod and
SaveModSettings are refused on a release older than v0.2.0-beta (or of no readable version in its release.json), in both
the adapter (Test-LegacyReleaseMods) and the UI; v0.2.0-beta and later take downloaded mods.
SaveContentSettings takes a staged JSON object, ModId, ModTarget (Modules or Leagues) and ModExpectedHash. It verifies a
unique physical manifest and declaration before writing only data/modules/.json or data/leagues/.json.
SaveLeagueModules takes a reviewed staged override object and expected hash; it verifies the capability, array/path
shape and protection of Core/Game, then writes only the configured user override file. The planner and backend both
check installed modules and dependencies and preserve the choices of other leagues. Neither action starts or stops a
server. Membership is a next-start choice, never a claim that the running server applied it.
League changes now use an envelope with league, choices and review. review maps every relevant module manifest,
league definition/list/settings/source file and custom marker to its SHA-256, plus the user override file. The inventory
must match exactly, including new/deleted files. LeagueData.py validates dependencies, cycles, required dedicated bundles,
parent chains and a whole-composition witness from an existing same-family/mode profile. Only the selected league's
override can change; other entries remain byte-value equivalent. Prior configuration is retained before atomic replacement.
The helper accepts UTF-8 JSON requests with or without one leading BOM, including Windows PowerShell pipeline input.
Duplicate keys and malformed JSON remain rejected before configuration writes.
CreateLeague requires the source league-loader hook (CanCreate), a new safe name, an empty marker template and isolated
Void. It does not wait for save writers to stop: LocalExile reads its leagues once, when a server starts. LeagueData.py opens the selected
database read-only (with a split layout's auth.db attached), verifies the known schema/import state and refuses retained league names in character and stash data.
It writes only a new physical directory, with independent identity, Void transitions and unchanged template mode flags.
An exclusive directory reservation and a final no-replace manifest publication prevent partial leagues from being loaded
or existing leagues from being overwritten. This operation never changes existing league source, saves or runtime state.
SetLeagueVisibility takes league, boolean visible, and review. It changes only the top-level creatable flag in
existing definitions, preserving comments and all other fields. Card-link closure prevents orphaned mode options and the
last playable main card cannot be hidden. Writers need not be stopped; the league-loader capability
and current review inventory are required. Original definitions are retained, each replacement is atomic, and failures
roll back only files still matching this operation's output. Ordering keeps intermediate card states valid. No save
database is read or written for visibility. It is a global creation-list control, never per-account filtering or ending.
Both actions hold the existing writer lock and reject ownership conflicts. A failed optional save backup blocks the write; the expected hash is checked again after backup. Before replacement, the previous configuration is copied to a unique Waypoint config-history directory. Staging is accepted only from physical files under Waypoint's mod-downloads directory. SaveModSettings also accepts the reviewed expected hash and preserves the previous values file in config-history.
Interface language is a launcher-only optional settings field (Language: a tag of L.Languages, en, ru or zh-CN;
Waypoint's own settings leave it empty until the player picks one, which follows the system's display language). It is never
forwarded to the runtime adapter, used to rewrite action/status tokens, or stored in LocalExile saves or backup metadata.
Translated presentation preserves captured paths, IDs and native game commands. Raw runtime/diagnostic output remains
available in its original form. See localization for the satellite-file packaging requirement.
Appearance is another optional launcher-only settings object. Legacy settings retain the Waypoint dark theme.
It records the appearance mode, scheme, separate custom light/dark role colors, and reading/accessibility options.
These settings are not passed to LocalExile. Theme detection reads the Windows application-theme preference and
listens for changes; it never writes Windows registry values or installs fonts. Appearance previews write no settings
until Apply; Cancel restores the prior appearance. The embedded OpenDyslexic font retains its OFL notice in packages.
ModuleIcons is a launcher-only map of checkout and module ID to a stable library key. Missing or unknown choices use
the module's default icon. These preferences are never forwarded to the runtime adapter or stored in LocalExile files;
changing an icon performs no checkout operation and does not reload gameplay code or settings.