Upgrade from the card, behind a three-dot menu

An installed title's version line now reads `0.1 → 0.3` where the catalog has moved on, so a card answers both questions somebody brings to it: what is installed, and is there anything better. Which version is installed was already recorded — `state.json` has always carried it — what was missing was anywhere to act on it. The card leads with Play (or Open, for a hosted title) and puts the rest behind a ⋮ button: Upgrade, which fetches whatever the catalog now has, and Uninstall. Upgrade stays visible while disabled rather than appearing and disappearing — a menu whose items come and go makes a person hunt for the one they used last time, and greyed out already says "not now". Playing stays the headline even with an upgrade waiting: the build on the disk still runs, and wanting to play it is not the same as wanting to wait for a download. The menu is a `<details>`, so its open state is the DOM's and the keyboard needs no teaching. Closing it on an outside click is the grid's job, not a card's: cards are rebuilt on every render, so a listener per card would be a listener per render. Package names lose their spaces — `WarpEngineClient-2.3.0-arm64.dmg` — because a space in a release asset is a space in every curl, script and shell command that touches it. Set per target rather than globally: nsis and portable would otherwise resolve to the same .exe name and overwrite each other. `productName` is untouched, so the app is still called WarpEngine Client where a person sees it — in the Dock and in /Applications. Tested on a sandbox store by rewriting one state record to claim an older build, which is what the engine actually compares: the window then offered `Upgrade:on` for that title and `Upgrade:off` for the current one, and pressing it took the record from 0.1 to 0.2 with the old payload removed first. The self-test asserts that pairing on every installed card, because a closed menu photographs identically whether or not its items are right. In Hungarian the catalog refresh and the new Upgrade both wanted "Frissítés"; the refresh is an icon with a tooltip, and a tooltip can afford to say *Katalógus frissítése*. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
A registry record is a name and a catalog
2026-08-19 08:17:43 +02:00 · 2026-08-19 07:27:52 +02:00
22 changed files with 394 additions and 365 deletions
@@ -62,49 +62,34 @@ and there is nothing to decide; several and the setup screen shows a picker.
 ```json
 [
-  {
+  { "name": "Teletype Games", "catalogUrl": "https://teletypegames.org" },
-    "name": "Teletype Games",
+  { "name": "Some Other Store", "catalogUrl": "https://games.example.org" }
    "catalogUrl": "https://teletypegames.org",
    "storeRepositoryUrl": "https://git.teletypegames.org/stores/ttg-desktop-store",
    "config": { "store": { "id": "ttg" }, "paths": { "subfolder": "teletypegames" } }
  },
  { "name": "Some Other Store", "catalogUrl": "https://games.example.org",
    "storeRepositoryUrl": null, "config": null }
 ]
 ```
-**A store needs nothing of its own.** A name and a catalog are enough: the store
+**A name and a catalog are the whole record.** The store engine's built-in defaults
-engine's built-in defaults already cover the host-to-asset mapping, the install modes,
+already cover the host-to-asset mapping, the install modes, the platforms and the
-the platforms and the behaviour, so what is actually missing from them is identity — a
+behaviour, so what is actually missing from them is identity — and identity is all a
-slug, a name and a catalog URL — and that is exactly what a registry record carries.
+registry says. Nothing a record carries decides where files go: how a store behaves is
-With `config` and `storeRepositoryUrl` both null the client writes a three-section
+fixed per installed client, which knows its own machine, and a copy of that on a server
-config and the store installs.
+would be a second authority over decisions this side has already made.
-Where a store's configuration comes from, in the order the client asks:
+From a record the client works out the rest:
-1. **`config` on the registry record** — the store's own configuration, in the same
+- **the store id** — which names the store home and the folder games land in — is a slug
-   shape a store's `config.json` had, because it is that file moved into the registry.
+  of the catalog host (`teletypegames.org` becomes `teletypegames`), or of the display
-   It costs no request: it arrived with the store list.
+  name if that fails. Derived from the *catalog* on purpose: the catalog is what a store
-2. **`storeRepositoryUrl` → `…/raw/branch/master/config.json`** — the same thing in its
+  is, so two records naming the same one are the same store and land in the same place.
-   older home, read for a registry whose stores have not moved over yet. A repository
+  Reinstalling therefore never orphans what is already installed.
-   **without** a `config.json` is treated as no repository at all.
+- **the games folder** is that same slug inside the OS's usual place for programs, and it
-3. **the engine's defaults** — when there is neither.
+  is the only subtree this store will ever delete from. That is the whole of how two
  stores on one machine stay out of each other's files: a subfolder, derived here.
 - **released, archived and demo** titles are listed, where the engine alone would show
  released and archived only — a catalog that publishes a demo means it to be played.
-Two fields the record always decides, whatever the config says:
+Because a record has no paths in it and no config, there is nothing for the window to
-
+tamper with: `RegistryStoreDtoMapper.toModel` can take its choice at face value, and the
- **`catalogUrl` and `name`** override the config's own `store.base_url` and
+config that lands on disk is written by the installer from the engine's own defaults.
  `store.name`. The registry says which catalog this store is *for*, so it wins.
 - **the store id** — which names the store home and the folder games land in — comes
  from the config's `store.id` when it sets one; otherwise from the repository name
  (`ttg-desktop-store` becomes `ttg`), then the catalog host (`teletypegames.org`
  becomes `teletypegames`), then the display name.
 **The window never supplies a config.** It is handed stores to show and hands one back
 to install, but only as an identity: `RegistryStoreDtoMapper.toModel` drops the config,
 and `StoreProvisioningService` reads the record again from the registry before
 installing. A config decides where files are written and which subtree the store may
 later delete from, so it must not be something the renderer can set — the same rule as
 `GameDto` carrying no paths.
 What the defaults produce, for a record with no repository: the games land in a
 folder named after the store id, and released, archived **and demo** titles are
@@ -287,9 +272,14 @@ on its own: publishing 1.2.0 got *"invalid username, password or token"* on the
 second package while the first had just gone up with the same token, and the same
 command succeeded immediately afterwards.
-Package names contain a space — `WarpEngine Client-1.5.0-arm64.dmg` — so the list of
+Package names have no spaces in them — `WarpEngineClient-2.3.0-arm64.dmg` — because a
-files is passed one path per line rather than as one string; splitting it on
+space in a release asset is a space in every `curl`, script and shell command that ever
-whitespace is what broke the first attempt at publishing 1.1.0.
+touches it. The app itself is still called **WarpEngine Client**: that name is what
 appears in the Dock and in `/Applications`, and only the file names were the problem.
 The list of files is still passed one path per line rather than as one string, since a
 path given on the command line can contain a space even when a built one cannot;
 splitting it on whitespace is what broke the first attempt at publishing 1.1.0.
 It needs `tea` installed and logged in — the devarea repo has `make tea` for that.
 Overridable: `TAG`, `REPO`, `TEA_LOGIN`, `NOTES`, `DIST`.
@@ -390,6 +380,18 @@ across them. One class serving three versions is the honest way to say that.
 ## Verified, and not
 **2.2.0** — the registry record was cut back to a name and a catalog, so the whole
 install path was measured again against a local registry serving exactly that. The slug
 came out `teletypegames` from the catalog host, the home `teletypegames-desktop`, the
 games subfolder `teletypegames`, and installing the same record twice landed in the same
 home. A record carrying `config` and `storeRepositoryUrl` — the fields a stale client or a
 tampering renderer might still send — changed nothing, because neither exists in the model
 any more. The site side was migrated and its specs re-run; the frontend was built, which
 first required removing a dead `engines` list that had been failing `vue-tsc` on master.
 Older entries below describe what was verified for the version they name, and some of
 them predate the store engine moving into this application.
 The pipeline's commands were run in the same containers it uses, before the pipeline was
 committed: `electronuserland/builder:22` installs, type-checks, lints, passes the smoke
 test (registry reached, store skipped as it should be on a machine that has none) and
@@ -1,29 +1,39 @@
-# WarpEngine Client 2.1.0
+# WarpEngine Client 2.3.0
-**A store's configuration now comes from the registry itself.** `GET /api/stores`
+**A card says which version you have, and offers the newer one.** Where the catalog has
-records carry a `config` field — the same thing a store's `config.json` held, moved into
+moved on, an installed title's version line reads `0.1 → 0.3` instead of just the number
-the record that already says what the store is. The client applies it directly, so
+on your disk, so the card answers both questions a person came to it with: what is
-installing a store no longer depends on a second repository existing and staying
+installed, and is there anything better.
 reachable, and a store can be configured entirely from the site's admin.
-The old path still works. Where a record has no `config` but names a repository, the
+Which version is installed was already recorded — that is what `state.json` has always
-client reads `…/raw/branch/master/config.json` from it exactly as before, so a registry
+been for. What was missing was somewhere to act on it.
 whose stores have not moved over is unaffected. With neither, the engine's defaults
 carry the store, as they always have. The order is: registry config, then repository
 file, then defaults.
-**The window cannot supply a store config.** It is handed stores to show and hands one
+**The actions moved into a three-dot menu.** Installed cards now lead with **Play** (or
-back to install, but only as an identity — the config is dropped on the way in, and the
+**Open** for a hosted title) and put the rest behind the ⋮ button beside it:
-main process reads the record again from the registry before installing anything. This
+
-is not tidiness: a config decides where files are written and, through
+| | |
-`paths.subfolder`, which subtree the store may later delete from. That is not a decision
+|---|---|
-the renderer gets to make, for the same reason a `GameDto` carries no paths.
+| **Upgrade** | fetches whatever the catalog now has, replacing the old payload and menu entry. Greyed out when there is nothing newer |
 | **Uninstall** | as before — the payload, the icon and the menu entry, and nothing else |
 Upgrade stays visible while disabled rather than appearing and disappearing: a menu whose
 items come and go makes a person hunt for the one they used last time, and greyed out
 already says "not now".
 Playing stays the headline action even when an upgrade is waiting. The version on the disk
 still runs, and wanting to play it is not the same as wanting to wait for a download.
 **Package names have no spaces.** `WarpEngineClient-2.3.0-arm64.dmg` rather than
 `WarpEngine Client-2.3.0-arm64.dmg`, and the same for the AppImage and both Windows
 builds — a space in a release asset is a space in every `curl`, script and shell command
 that ever touches it. The app is still called **WarpEngine Client**, which is what appears
 in the Dock and in `/Applications`; only the file names changed.
 ### Also
-The headless check now reports *which* source configured a store — registry, repository
+The catalog refresh control's tooltip now says *Refresh the catalog*, because in Hungarian
-or defaults — and names the resulting prune boundary, because "it installed" and "it
+it and the new Upgrade both wanted the word "Frissítés" and only one of them reloads a
-installed where I meant" are different claims.
+list.
 ### Opening it on macOS
@@ -40,19 +50,23 @@ Windows (installer, portable) packages the pipeline builds when the tag is pushe
 ### Verified
-`make check` is clean: typecheck, lint, the headless smoke test and the window
+`make check` is clean: typecheck, lint, the headless smoke test and the window self-test.
 self-test.
-All three configuration sources were exercised end to end against the real serializer
+The upgrade path was tested on a sandbox store rather than reasoned about. Two titles were
-output, with the client's own classes and a sandbox store root:
+installed, then one of their state records was rewritten to claim an older build — which is
 exactly what the engine compares — and the window was asked what it would offer:
-| Registry record | What configured the store | Prune boundary written |
+```
-|---|---|---|
+BombExpert    [newer]   Upgrade:on  Uninstall:on
-| `config` present | the registry, with no extra request | `teletypegames` |
+Rabbit Roller [current] Upgrade:off Uninstall:on
-| `config: null`, repository given | the repository's `config.json` | `teletypegames` |
+```
 | neither | the engine's defaults | `teletypegames` |
-The renderer barrier was tested adversarially rather than assumed: an install started
+Pressing Upgrade runs the same call the window makes, and the record went from `0.1` to
-from a record carrying `paths.subfolder: "ATTACKER"` and `paths.install_root:
+`0.2` with the old payload removed first. The self-test now asserts that pairing on every
-"/tmp/pwned"` wrote `subfolder: teletypegames` and `install_root: null` to disk, because
+installed card, because a closed menu photographs identically whether or not its items are
-the service re-read the registry and the mapper had already dropped the config.
+right.
 The new package names were read off a real build (`WarpEngineClient-2.3.0-arm64.dmg`,
 `…-arm64-mac.zip`) and checked against the release script's own file filter, which finds
 both. The Windows names are `-Setup-` and `-Portable-` so the two `.exe` targets cannot
 resolve to one name and overwrite each other.
@@ -1,7 +1,7 @@
 {
  "name": "warp-engine-client",
  "productName": "WarpEngine Client",
-  "version": "2.1.0",
+  "version": "2.3.0",
  "description": "Graphical client for WarpEngine stores: install a catalog into your own application menu.",
  "license": "MIT",
  "author": "Teletype Games <games@teletype.hu>",
@@ -44,7 +44,11 @@
      "target": [
        "dmg",
        "zip"
-      ]
+      ],
      "artifactName": "WarpEngineClient-${version}-${arch}-mac.${ext}"
    },
    "dmg": {
      "artifactName": "WarpEngineClient-${version}-${arch}.${ext}"
    },
    "win": {
      "target": [
@@ -52,6 +56,12 @@
        "portable"
      ]
    },
    "nsis": {
      "artifactName": "WarpEngineClient-Setup-${version}-${arch}.${ext}"
    },
    "portable": {
      "artifactName": "WarpEngineClient-Portable-${version}-${arch}.${ext}"
    },
    "linux": {
      "category": "Game",
      "target": [
@@ -59,6 +69,9 @@
        "deb"
      ]
    },
    "appImage": {
      "artifactName": "WarpEngineClient-${version}-${arch}.${ext}"
    },
    "afterPack": "scripts/after-pack.js"
  },
  "allowScripts": {
@@ -53,9 +53,10 @@ api() {
  curl -fsS -X "$method" -H "$AUTH" "$FORGE$path" "$@"
 }
-# Package names contain spaces — "WarpEngine Client Setup 1.5.0.exe" does — so the list
+# The list lives one path per line in a file and is read with `while IFS= read -r`. The
-# lives one path per line in a file and is read with `while IFS= read -r`. A single
+# built package names have no spaces in them any more, but a path given on the command
-# variable looped over with $list splits on the space and uploads nothing.
+# line still can — and a single variable looped over with $list splits on the space and
 # uploads nothing, which is a silent way to publish a release with no assets.
 LIST="$(mktemp)"
 trap 'rm -f "$LIST"' EXIT
 if [ "$#" -gt 0 ]; then
@@ -43,9 +43,10 @@ REPO="${REPO:-$(git remote get-url origin 2>/dev/null |
 #
 #   - the version filter, because dist/ keeps whatever earlier builds left there
 #     and a release would quietly get the previous version's files attached;
-#   - the spaces. "WarpEngine Client-1.5.0-arm64.dmg" has one, so the list lives one
+#   - the spaces. The built names have none since 2.3.0 — `WarpEngineClient-2.3.0-arm64.dmg`
-#     path per line in a file and is read with `while IFS= read -r`. Holding it in
+#     — but a path given as an argument still can, so the list stays one path per line in
-#     a single variable and looping over $list splits it on the space.
+#     a file, read with `while IFS= read -r`. Holding it in a single variable and looping
 #     over $list splits it on the space, and publishes nothing.
 LIST="$(mktemp)"
 trap 'rm -f "$LIST"' EXIT
 if [ "$#" -gt 0 ]; then
@@ -7,7 +7,6 @@ export class RegistryStoreDtoMapper {
    return {
      name: store.name,
      catalogUrl: store.catalogUrl,
      storeRepositoryUrl: store.storeRepositoryUrl,
      storeId: deriveStoreId(store)
    }
  }
@@ -16,20 +15,8 @@ export class RegistryStoreDtoMapper {
    return stores.map((store: RegistryStore): RegistryStoreDto => this.toDto(store))
  }
-  /**
+  /** The window hands a record straight back when asking for an install. */
   * The window hands a record back when asking for an install — as an identity only.
   *
   * There is no `config` here on purpose. A store's config decides where files are
   * written and which subtree the store may delete from, so it must not be something
   * the window can supply; `StoreProvisioningService` reads the real record from the
   * registry instead. That is the same rule as `GameDto` carrying no paths.
   */
  public toModel (dto: RegistryStoreDto): RegistryStore {
-    return {
+    return { name: dto.name, catalogUrl: dto.catalogUrl }
      name: dto.name,
      catalogUrl: dto.catalogUrl,
      storeRepositoryUrl: dto.storeRepositoryUrl,
      config: null
    }
  }
 }
@@ -30,45 +30,21 @@ export class StoreProvisioningService {
    return this.registry.listStores()
  }
  /**
   * Install the chosen store.
   *
   * The window's choice is taken at face value, which is safe because a record is only a
   * name and a catalog: there is no path in it and nothing that decides what may be
   * deleted. The store's own configuration is written by the installer from the engine's
   * defaults, so the renderer cannot influence where anything lands.
   */
  public async installStore (
-    chosen: RegistryStore,
+    store: RegistryStore,
    progress?: EngineProgressListener
  ): Promise<InstalledStore> {
    const store = await this.resolveFromRegistry(chosen, progress)
    const home = this.stores.resolveDefaultHome(deriveStoreId(store))
    const installed = await this.installer.installEngine(home, store, progress)
    return this.selection.adoptStore(installed)
  }
  /**
   * The registry's own record for the store that was chosen.
   *
   * The window is handed stores to display and hands one back to install, but what it
   * hands back is not what gets used. A store's config decides where files are written
   * and which subtree the store may later delete from, so it cannot be something the
   * window supplies — the choice is treated as an identity, a name and a catalog, and
   * the record behind it is read again here.
   *
   * A store that has since left the registry, or a registry that cannot be reached, is
   * not a reason to refuse the install: it proceeds on the engine's defaults, which is
   * what a store with no config gets anyway.
   */
  private async resolveFromRegistry (
    chosen: RegistryStore,
    progress?: EngineProgressListener
  ): Promise<RegistryStore> {
    try {
      const listed = await this.registry.listStores()
      const found = listed.find((store: RegistryStore): boolean =>
        store.catalogUrl === chosen.catalogUrl && store.name === chosen.name)
      if (found !== undefined) return found
      progress?.onLog?.(
        `${chosen.name} is no longer in the registry — installing on the engine's defaults`)
    } catch (error: unknown) {
      const reason = error instanceof Error ? error.message : String(error)
      progress?.onLog?.(
        `the registry could not be read again (${reason}) — installing on the engine's defaults`)
    }
    return { ...chosen, config: null }
  }
 }
@@ -1,24 +1,15 @@
 /**
- * A store the site's registry offers.
+ * A store the site's registry offers: a name and a catalog.
 *
- * A name and a catalog are what make a store; the other two fields are optional.
+ * That is the whole record, and it is enough. How a store behaves is not the registry's
 * business — this client carries its own store engine, whose defaults cover the
 * host-to-asset mapping, the install modes, the platforms and the behaviour — so what
 * was actually missing from those defaults is identity, and identity is all this is.
 *
- * `config` is how that store behaves — which platforms it offers, which release
+ * Keeping two stores on one machine out of each other's files is a subfolder, derived
- * statuses it shows, where its games land — in the same shape a store's `config.json`
+ * here from the store's own slug rather than told to us by a server.
 * had, because it is the same thing moved into the registry. With none, the engine's
 * defaults cover all of it and this record covers the identity, which is why a store
 * needs nothing of its own to be installable.
 *
 * `storeRepositoryUrl` is where the store's own repository is, when it has one. It is
 * still read as a config source for a registry that has not moved its stores over yet.
 */
 export interface RegistryStore {
  readonly name: string
  readonly catalogUrl: string
  readonly storeRepositoryUrl: string | null
  /**
   * Deliberately not `JsonRecord`: `domain` imports nothing from `infrastructure`, and
   * a JSON object is describable without it.
   */
  readonly config: Readonly<Record<string, unknown>> | null
 }
@@ -3,28 +3,22 @@ import type { RegistryStore } from './RegistryStore'
 /**
 * A store id, from whatever the registry gave us.
 *
- * The id names the store home, the folder games land in and the launcher files, so
+ * The id names the store home, the folder games land in and the launcher files, so it
- * it has to be short and filesystem-safe. Three sources, in order of how much they
+ * has to be short and filesystem-safe. Two sources, in order of how much they were
- * were meant to be a name:
+ * meant to be a name:
 *
- *   1. the repository name — `ttg-desktop-store` becomes `ttg`;
+ *   1. the catalog host — `https://teletypegames.org` becomes `teletypegames`;
- *   2. the catalog host — `https://teletypegames.org` becomes `teletypegames`;
+ *   2. the display name, slugged, as a last resort.
 *   3. the display name, slugged, as a last resort.
 *
- * The store's own config.json overrides all of it whenever one exists.
+ * Derived rather than carried, and derived from the catalog: the catalog is what a store
 * *is*, so two records naming the same catalog are the same store and land in the same
 * place, which is what keeps a reinstall from orphaning what is already there.
 */
 export function deriveStoreId (store: RegistryStore): string {
-  const fromRepository = store.storeRepositoryUrl === null
+  return toSlug(readHostLabel(store.catalogUrl)) || toSlug(store.name) || 'store'
    ? ''
    : (lastSegment(store.storeRepositoryUrl).replace(/-(desktop-)?store$/, ''))
  return toSlug(fromRepository) || toSlug(readHostLabel(store.catalogUrl)) || toSlug(store.name) || 'store'
 }
-function lastSegment (url: string): string {
+/** `https://www.teletypegames.org/x` -> `teletypegames`. */
  return url.replace(/\/+$/, '').split('/').pop() ?? ''
 }
 /** `https://www.teletypegames.org/x` → `teletypegames`. */
 function readHostLabel (catalogUrl: string): string {
  try {
    const host = new URL(catalogUrl).hostname.replace(/^www\./, '')
@@ -1,7 +1,7 @@
 import { RegistryUnavailableError } from '../../domain/errors/RegistryUnavailableError'
 import type { RegistryStore } from '../../domain/models/RegistryStore'
 import type { StoreRegistryRepository } from '../../domain/ports/StoreRegistryRepository'
-import { asRecord, readRecord, readString, type JsonRecord } from '../json/JsonRecord'
+import { asRecord, readString, type JsonRecord } from '../json/JsonRecord'
 import { BuildConfiguration } from '../config/BuildConfiguration'
 import type { HttpTextClient } from '../http/HttpTextClient'
@@ -15,10 +15,10 @@ const DEFAULT_REGISTRY_URL = 'https://teletypegames.org/api/stores'
 * field a build was packaged with (for shipping a client for another site), and finally
 * the address of ours.
 *
- * A record needs a name and a catalog URL; those two make a store. The config and the
+ * A name and a catalog URL make a store, and are all a record carries. Anything else it
- * repository are both optional and arrive as null when absent — a store configured by
+ * happens to say is ignored: how a store behaves is this client's own business, decided
- * nothing but this record installs on the engine's defaults. Records missing either of
+ * by the engine it ships with. Records missing either field are dropped rather than
- * the two required fields are dropped rather than half-used.
+ * half-used.
 */
 export class HttpStoreRegistryRepository implements StoreRegistryRepository {
  public readonly sourceUrl: string
@@ -44,19 +44,12 @@ export class HttpStoreRegistryRepository implements StoreRegistryRepository {
    return parsed
      .map((row: unknown): JsonRecord | null => asRecord(row))
      .filter((row: JsonRecord | null): row is JsonRecord => row !== null)
-      .map((row: JsonRecord): RegistryStore => {
+      // Both spellings, because a registry is someone else's API: ours answers
-        // Both spellings, because a registry is someone else's API: ours answers
+      // camelCase, and a hand-rolled one may not.
-        // camelCase, and a hand-rolled one may not.
+      .map((row: JsonRecord): RegistryStore => ({
-        const repository = (
+        name: readString(row, 'name').trim(),
-          readString(row, 'storeRepositoryUrl') || readString(row, 'store_repository_url')
+        catalogUrl: (readString(row, 'catalogUrl') || readString(row, 'catalog_url')).trim()
-        ).trim()
+      }))
        return {
          name: readString(row, 'name').trim(),
          catalogUrl: (readString(row, 'catalogUrl') || readString(row, 'catalog_url')).trim(),
          storeRepositoryUrl: repository.length > 0 ? repository : null,
          config: readRecord(row, 'config')
        }
      })
      .filter((store: RegistryStore): boolean =>
        store.name.length > 0 && store.catalogUrl.length > 0)
  }
@@ -6,12 +6,8 @@ import type { RegistryStore } from '../../domain/models/RegistryStore'
 import { DESKTOP_STORE_ENGINE } from '../../domain/models/StoreEngine'
 import { deriveStoreId } from '../../domain/models/StoreIdentity'
 import type { StoreEngineInstaller } from '../../domain/ports/StoreEngineInstaller'
 import { asRecord, readString } from '../json/JsonRecord'
 import { HttpStatusError, type HttpTextClient } from '../http/HttpTextClient'
 const CONFIG_FILE_NAME = 'config.json'
 const DEFAULT_FORGE_BASE = 'https://git.teletypegames.org'
 const DEFAULT_BRANCH = 'master'
 /** What an install used to leave in a store home, back when the engine was a script. */
 const RETIRED_ENGINE_FILES: readonly string[] = ['desktop_store.py', 'warpstore.py']
@@ -19,51 +15,63 @@ const RETIRED_ENGINE_FILES: readonly string[] = ['desktop_store.py', 'warpstore.
 /**
 * Setting up a store where there is none.
 *
- * Since the engine moved into this application there is nothing to download but the
+ * Nothing is downloaded and nothing is asked of a server. The engine ships in this
- * store's own configuration, so an install is one HTTP call and one file. The store
+ * application and its defaults already cover the host-to-asset mapping, the install
- * home stays where it was and keeps its name, because the state and the catalog cache
+ * modes, the platforms and the behaviour; what a registry record adds is identity — a
- * beside that config are what make an existing library recognisable.
+ * name, a catalog and a slug — and that is what gets written.
 *
 * The config is written to disk rather than kept in memory because it is the store's
 * own record of itself: `StoreConfigurationReader` reads it on every operation, an
 * existing store home is recognised by it, and a person can look at it.
 */
 export class NativeStoreEngineInstaller implements StoreEngineInstaller {
-  private readonly forgeBase: string
+  public installEngine (
  public constructor (private readonly httpClient: HttpTextClient, forgeBase?: string) {
    const configured = process.env['FORGE_BASE']
    this.forgeBase = forgeBase ?? (configured !== undefined && configured.length > 0
      ? configured
      : DEFAULT_FORGE_BASE)
  }
  public async installEngine (
    home: string,
    store: RegistryStore,
    progress: EngineProgressListener = {}
  ): Promise<InstalledStore> {
    fs.mkdirSync(home, { recursive: true })
-    const config = await this.readStoreConfig(store, progress)
+    const storeId = deriveStoreId(store)
    const configPath = path.join(home, CONFIG_FILE_NAME)
-    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`)
+    fs.writeFileSync(configPath, `${JSON.stringify(this.buildConfig(store, storeId), null, 2)}\n`)
    this.removeRetiredEngine(home, progress)
    progress.onLog?.(`${store.name} is set up in ${home}`)
-    const configStore = asRecord(config['store'])
+    return Promise.resolve({
-    return {
+      id: storeId,
      id: configStore === null ? deriveStoreId(store) : readString(configStore, 'id', deriveStoreId(store)),
      name: store.name,
      home,
      configPath,
      engine: DESKTOP_STORE_ENGINE.id
    })
  }
  /**
   * The store's configuration: its identity, and the two things worth stating.
   *
   * Everything absent from this falls to the engine's defaults, which is most of it. The
   * subfolder is named after the store so two stores on one machine cannot reach into
   * each other's files — it is the prune boundary, so it has to be the store's own.
   * Demo titles are listed because a catalog that publishes them means them to be
   * played; the engine defaults to released and archived only, which is the safer
   * default for a store nobody configured.
   */
  private buildConfig (store: RegistryStore, storeId: string): Record<string, unknown> {
    return {
      store: { id: storeId, name: store.name, base_url: store.catalogUrl },
      paths: { subfolder: storeId },
      catalog: { statuses: ['released', 'archived', 'demo'] }
    }
  }
  /**
   * Clear out the scripts an older client downloaded here.
   *
-   * A store home provisioned by 1.5.0 or by the shell installer holds two Python
+   * A store home provisioned by 1.5.0 or by a shell installer holds two Python files
-   * files that nothing reads any more. They are harmless, but a directory that still
+   * that nothing reads any more. They are harmless, but a directory that still looks
-   * looks like it holds the engine invites someone to run it against a state file
+   * like it holds the engine invites someone to run it against a state file this
-   * this application is also writing.
+   * application is also writing.
   */
  private removeRetiredEngine (home: string, progress: EngineProgressListener): void {
    for (const fileName of RETIRED_ENGINE_FILES) {
@@ -73,88 +81,4 @@ export class NativeStoreEngineInstaller implements StoreEngineInstaller {
      progress.onLog?.(`removed the retired ${fileName}`)
    }
  }
  /**
   * The store's configuration.
   *
   * Four cases, and all of them install:
   *
   *   - **a config on the registry record** — the authority on how the store behaves:
   *     which platforms it offers, which statuses it shows, where things land. No
   *     request at all, because it arrived with the store list;
   *   - **a repository with a config.json** — the same thing in its older home, read
   *     for a registry whose stores have not moved over yet;
   *   - **a repository without one** (404) — the engine's defaults, as below;
   *   - **neither** — the same defaults, without the round trip.
   *
   * The engine's built-in defaults already cover the host-to-asset mapping, the
   * modes, the platforms and the behaviour, so what a store actually has to supply is
   * identity: a slug, a name and a catalog. That is exactly what a registry record
   * carries, which is why a store needs no repository of its own. The registry always
   * wins on those three, whatever a config file says.
   */
  private async readStoreConfig (
    store: RegistryStore,
    progress: EngineProgressListener
  ): Promise<Record<string, unknown>> {
    const storeId = deriveStoreId(store)
    const config = await this.readPublishedConfig(store, storeId, progress)
    const existing = asRecord(config['store']) ?? {}
    config['store'] = {
      ...existing,
      id: readString(existing, 'id', storeId),
      name: store.name,
      base_url: store.catalogUrl
    }
    return config
  }
  private async readPublishedConfig (
    store: RegistryStore,
    storeId: string,
    progress: EngineProgressListener
  ): Promise<Record<string, unknown>> {
    // The registry's own answer wins, and needs no request: a store's configuration is
    // part of its record now rather than a file in a repository that has to exist and
    // stay reachable.
    if (store.config !== null) {
      progress.onLog?.(`${store.name} is configured by the registry`)
      return { ...store.config }
    }
    const repositoryUrl = store.storeRepositoryUrl
    if (repositoryUrl === null) {
      progress.onLog?.(`${store.name} has no store repository — using the engine defaults`)
      return this.defaultConfig(storeId)
    }
    try {
      progress.onLog?.(`reading the store config from ${repositoryUrl}`)
      const body = await this.httpClient.readText(this.configUrl(repositoryUrl))
      return { ...(asRecord(JSON.parse(body)) ?? {}) }
    } catch (error: unknown) {
      if (!(error instanceof HttpStatusError) || error.statusCode !== 404) throw error
      progress.onLog?.('no config.json in the store repository — using the engine defaults')
      return this.defaultConfig(storeId)
    }
  }
  /**
   * What a store gets when nothing else says otherwise.
   *
   * Two fields, on top of the identity added by the caller. The subfolder keeps two
   * stores on one machine out of each other's files, and it is the prune boundary, so
   * it must be the store's own. Demo titles are listed because a catalog that
   * publishes them means them to be played — the engine defaults to released and
   * archived only, which is the safer default for a store nobody configured.
   */
  private defaultConfig (storeId: string): Record<string, unknown> {
    return {
      paths: { subfolder: storeId },
      catalog: { statuses: ['released', 'archived', 'demo'] }
    }
  }
  private configUrl (repositoryUrl: string, branch: string = DEFAULT_BRANCH): string {
    return `${repositoryUrl.replace(/\/+$/, '')}/raw/branch/${branch}/${CONFIG_FILE_NAME}`
  }
 }
@@ -48,7 +48,7 @@ export class ServiceContainer {
    const stores = new FileSystemInstalledStoreRepository()
    const catalogGateway = new NativeStoreCatalogGateway()
    const registry = new HttpStoreRegistryRepository(httpClient)
-    const installer = new NativeStoreEngineInstaller(httpClient)
+    const installer = new NativeStoreEngineInstaller()
    const preferencesRepository = new JsonFilePreferencesRepository(environment)
    const preferences = new PreferencesService(preferencesRepository, environment)
@@ -28,6 +28,8 @@ interface SelfTestReport {
  readonly locales: readonly string[]
  /** `<accessible name>:<glyph count>` per icon-only control in the footer. */
  readonly iconControls: readonly string[]
  /** `<title> [current|newer] Upgrade:on|off Uninstall:on|off` per installed card. */
  readonly cardMenus: readonly string[]
 }
 /** What changed after clicking a store that was not open. */
@@ -74,7 +76,11 @@ export class SelfTestRunner {
    // picker are the only way to reach those two actions now that neither has a label.
    const iconsNamed = report.iconControls.length === 2 &&
      report.iconControls.every((control: string): boolean => /^.+:1$/.test(control))
-    const rendered = report.locales.length > 1 && iconsNamed && (
+    // Every installed card offers both actions, and Upgrade is enabled exactly when the
    // version line says there is something newer. Uninstall is always available.
    const menusAgree = report.cardMenus.every((entry: string): boolean =>
      /\[newer\] \S+:on \S+:on$/.test(entry) || /\[current\] \S+:off \S+:on$/.test(entry))
    const rendered = report.locales.length > 1 && iconsNamed && menusAgree && (
      (report.cards > 0 && !report.gateVisible && report.stores.length > 0 &&
        report.categories.length > 0 && report.activeCategory !== null) ||
      (report.gateVisible && report.gateAction.length > 0))
@@ -107,6 +113,16 @@ export class SelfTestRunner {
      locales: [...document.getElementById('locale').options].map((option) => option.value),
      // The two icon-only controls: a glyph with no accessible name is a button nobody
      // can identify, and the failure is silent because the icon still draws.
      // One entry per installed card: its title, whether the version line shows an
      // upgrade, and the menu's two items with their disabled state. This is the only
      // way to see that Upgrade is offered exactly when there is something newer —
      // a screenshot shows a closed menu.
      cardMenus: [...document.querySelectorAll('.card.is-installed')].map((card) => {
        const items = [...card.querySelectorAll('.menu-item')]
          .map((item) => item.textContent + (item.disabled ? ':off' : ':on'))
        const arrow = card.querySelector('.version.has-update') === null ? 'current' : 'newer'
        return (card.querySelector('h2') || {}).textContent + ' [' + arrow + '] ' + items.join(' ')
      }),
      iconControls: [...document.querySelectorAll('.side-tools .icon-btn')]
        .map((control) => {
          const named = control.getAttribute('aria-label') || control.getAttribute('title') ||
@@ -132,7 +148,8 @@ export class SelfTestRunner {
      paths: readString(record, 'paths'),
      logLines: readNumber(record, 'logLines'),
      locales: readStringArray(record, 'locales'),
-      iconControls: readStringArray(record, 'iconControls')
+      iconControls: readStringArray(record, 'iconControls'),
      cardMenus: readStringArray(record, 'cardMenus')
    }
  }
@@ -27,12 +27,9 @@ export function requireStringArray (value: unknown, name: string): readonly stri
 export function requireRegistryStore (value: unknown): RegistryStoreDto {
  const record = asRecord(value)
  if (record === null) throw new TypeError('a store record is required')
  const repository = readString(record, 'storeRepositoryUrl')
  const store: RegistryStoreDto = {
    name: readString(record, 'name'),
    catalogUrl: readString(record, 'catalogUrl'),
    // Optional: a store with no repository installs on the engine's defaults.
    storeRepositoryUrl: repository.length > 0 ? repository : null,
    storeId: readString(record, 'storeId')
  }
  if (store.name.length === 0 || store.catalogUrl.length === 0) {
@@ -47,6 +47,9 @@ export class RendererApplication {
    this.grid = new CatalogGridView(new GameCardView({
      onInstall: (name: string): void => { void this.catalog.syncGames([name]) },
      // The same call as an install: a sync of one name fetches whatever the catalog
      // now has for it, and the engine replaces the old payload and menu entry.
      onUpgrade: (name: string): void => { void this.catalog.syncGames([name]) },
      onLaunch: (name: string): void => { void this.catalog.launchGame(name) },
      onRemove: (name: string): void => { void this.catalog.removeGame(name) }
    }))
@@ -357,6 +357,56 @@ body.nav-closed .side { margin-left: calc(-1 * var(--side-width)); }
 }
 .actions { display: flex; gap: 8px; margin-top: auto; }
 /* --- the card's actions menu -------------------------------------------- */
 /*
 * A <details> holding the two actions that are not the card's headline. The card is the
 * positioning context, and the panel is pinned to the button's right edge so it opens
 * inward rather than off the side of the grid.
 */
 .menu { position: relative; margin-left: auto; }
 .menu-toggle { list-style: none; }
 /* Safari and Chrome each draw their own marker on a summary; both have to go. */
 .menu-toggle::-webkit-details-marker { display: none; }
 .menu-toggle::marker { content: ''; }
 .menu[open] .menu-toggle { color: var(--ink); background: var(--panel-2); border-color: var(--line); }
 .menu-items {
  position: absolute;
  right: 0;
  bottom: calc(100% + 6px);
  z-index: 20;
  min-width: 148px;
  display: flex;
  flex-direction: column;
  padding: 4px;
  gap: 2px;
  background: var(--panel-2);
  border: 1px solid var(--line);
  border-radius: 10px;
  box-shadow: 0 10px 28px rgb(0 0 0 / .45);
 }
 .menu-item {
  font: inherit;
  font-size: 13px;
  text-align: left;
  padding: 7px 10px;
  border: 0;
  border-radius: 7px;
  background: transparent;
  color: var(--ink);
  cursor: pointer;
  white-space: nowrap;
 }
 .menu-item:hover:not(:disabled) { background: #2b3746; }
 .menu-item:disabled { color: var(--ink-dim); opacity: .5; cursor: default; }
 .icon-dots { fill: currentColor; stroke: none; }
 /* An installed version with a newer one behind it: the arrow carries the news, so the
   colour only has to make it findable in a grid. */
 .version.has-update { color: var(--accent); font-weight: 600; }
 /* --- log ----------------------------------------------------------------
   No permanent footer: the panel is in the flow only while it is open, and the
   switch for it sits in the side menu with everything else that is not a title. */
@@ -9,7 +9,26 @@ export class CatalogGridView {
  private readonly grid = requireElement('grid', HTMLElement)
  private readonly empty = requireElement('empty', HTMLElement)
-  public constructor (private readonly cards: GameCardView) {}
+  public constructor (private readonly cards: GameCardView) {
    this.closeMenusOnOutsideClick()
  }
  /**
   * One listener for every card's actions menu.
   *
   * A `<details>` does not close when the pointer goes elsewhere, and a card cannot own
   * this: cards are rebuilt on every render, so a listener per card would be a listener
   * per render. The grid is created once, which makes it the right place for it.
   */
  private closeMenusOnOutsideClick (): void {
    document.addEventListener('click', (event: MouseEvent): void => {
      const target = event.target
      const clicked = target instanceof Node ? target : null
      for (const menu of this.grid.querySelectorAll('details.menu[open]')) {
        if (clicked === null || !menu.contains(clicked)) menu.removeAttribute('open')
      }
    })
  }
  public render (state: AppState): void {
    const shown = state.games.filter((game: GameDto): boolean => matchesFilter(game, state.filter))
@@ -4,6 +4,7 @@ import { createElement } from '../dom/Dom'
 export interface GameCardViewCallbacks {
  readonly onInstall: (name: string) => void
  readonly onUpgrade: (name: string) => void
  readonly onLaunch: (name: string) => void
  readonly onRemove: (name: string) => void
 }
@@ -11,8 +12,11 @@ export interface GameCardViewCallbacks {
 /**
 * One card.
 *
- * A card is a function of a title and the strings: it holds no state of its own, so
+ * A card is a function of a title and the strings: it holds no state of its own, so the
- * the grid can throw the lot away and rebuild after every listing.
+ * grid can throw the lot away and rebuild after every listing. The one exception is the
 * actions menu, whose open/closed state lives in a `<details>` element — and being
 * thrown away is exactly what should happen to an open menu when the catalog changes
 * under it.
 */
 export class GameCardView {
  public constructor (private readonly callbacks: GameCardViewCallbacks) {}
@@ -71,13 +75,30 @@ export class GameCardView {
      meta.appendChild(badge)
    }
    meta.appendChild(createElement('span', 'badge badge-plain', game.platform))
-    meta.appendChild(createElement('span', 'version',
+    meta.appendChild(this.createVersion(game, messages))
      game.installed && game.installedVersion !== null
        ? `${game.installedVersion} · ${messages.installed}`
        : game.version))
    return meta
  }
  /**
   * The version, and what the catalog has that this machine does not.
   *
   * Both numbers, when they differ: which version is installed is the thing a person
   * came to the card to find out, and "there is a newer one" is only meaningful next to
   * it. Where they agree, the second number would be noise.
   */
  private createVersion (game: GameDto, messages: MessageBundle): HTMLElement {
    if (!game.installed || game.installedVersion === null) {
      return createElement('span', 'version', game.version)
    }
    if (!game.updateAvailable) {
      return createElement('span', 'version', `${game.installedVersion} · ${messages.installed}`)
    }
    const version = createElement('span', 'version has-update',
      `${game.installedVersion} → ${game.version}`)
    version.title = messages.updateAvailable
    return version
  }
  private createActions (game: GameDto, messages: MessageBundle, busy: boolean): HTMLElement {
    const actions = createElement('div', 'actions')
@@ -89,25 +110,88 @@ export class GameCardView {
      return actions
    }
-    const primary = createElement('button', 'btn btn-primary')
+    actions.appendChild(this.createPrimary(game, messages, busy))
-    primary.disabled = busy
+    // Only an installed title has anything in the menu: nothing to upgrade and nothing
    // to uninstall until there is something on the disk.
    if (game.installed) actions.appendChild(this.createMenu(game, messages, busy))
    return actions
  }
-    if (game.installed && !game.updateAvailable) {
+  /**
   * The one action a card leads with.
   *
   * For an installed title that is playing it — including when an upgrade is waiting,
   * because the version on the disk still runs and wanting to play it is not the same
   * as wanting to wait for a download.
   */
  private createPrimary (game: GameDto, messages: MessageBundle, busy: boolean): HTMLElement {
    const primary = createElement('button', 'btn btn-primary')
    if (game.installed) {
      primary.textContent = game.mode === 'web' ? messages.open : messages.play
      primary.disabled = busy || !game.launchable
      primary.addEventListener('click', (): void => { this.callbacks.onLaunch(game.name) })
-    } else {
+      return primary
      primary.textContent = game.updateAvailable ? messages.update : messages.install
      primary.addEventListener('click', (): void => { this.callbacks.onInstall(game.name) })
    }
-    actions.appendChild(primary)
+    primary.textContent = messages.install
    primary.disabled = busy
    primary.addEventListener('click', (): void => { this.callbacks.onInstall(game.name) })
    return primary
  }
-    if (game.installed) {
+  /**
-      const remove = createElement('button', 'btn btn-ghost', messages.remove)
+   * The three-dot menu: upgrade, and uninstall.
-      remove.disabled = busy
+   *
-      remove.addEventListener('click', (): void => { this.callbacks.onRemove(game.name) })
+   * A `<details>` rather than a scripted popover, so the open state is the DOM's and the
-      actions.appendChild(remove)
+   * keyboard works without being taught to. Upgrade is present but disabled when there
   * is nothing newer — a menu whose items appear and disappear makes a person hunt for
   * the one they used last time, and "greyed out" already says "not now".
   */
  private createMenu (game: GameDto, messages: MessageBundle, busy: boolean): HTMLElement {
    const menu = createElement('details', 'menu')
    const toggle = createElement('summary', 'icon-btn menu-toggle')
    toggle.title = messages.moreActions
    toggle.setAttribute('aria-label', messages.moreActions)
    toggle.appendChild(this.createDotsIcon())
    menu.appendChild(toggle)
    const items = createElement('div', 'menu-items')
    items.appendChild(this.createMenuItem(messages.upgrade, busy || !game.updateAvailable,
      (): void => { this.callbacks.onUpgrade(game.name) }))
    items.appendChild(this.createMenuItem(messages.uninstall, busy,
      (): void => { this.callbacks.onRemove(game.name) }))
    menu.appendChild(items)
    return menu
  }
  private createMenuItem (
    label: string,
    disabled: boolean,
    perform: () => void
  ): HTMLButtonElement {
    const item = createElement('button', 'menu-item', label)
    item.disabled = disabled
    item.addEventListener('click', (): void => {
      // Close before acting: the click starts work that re-renders the grid, and a menu
      // left open would vanish mid-gesture rather than answer the press.
      item.closest('details')?.removeAttribute('open')
      perform()
    })
    return item
  }
  private createDotsIcon (): SVGSVGElement {
    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
    svg.setAttribute('class', 'icon icon-dots')
    svg.setAttribute('viewBox', '0 0 16 16')
    svg.setAttribute('aria-hidden', 'true')
    svg.setAttribute('focusable', 'false')
    for (const y of [3.5, 8, 12.5]) {
      const dot = document.createElementNS('http://www.w3.org/2000/svg', 'circle')
      dot.setAttribute('cx', '8')
      dot.setAttribute('cy', String(y))
      dot.setAttribute('r', '1.35')
      svg.appendChild(dot)
    }
-    return actions
+    return svg
  }
 }
@@ -3,7 +3,6 @@ import path from 'node:path'
 import { GameDtoMapper } from '../application/mappers/GameDtoMapper'
 import type { CatalogListing } from '../domain/models/CatalogListing'
 import type { InstalledStore } from '../domain/models/InstalledStore'
 import type { RegistryStore } from '../domain/models/RegistryStore'
 import { DESKTOP_STORE_ENGINE } from '../domain/models/StoreEngine'
 import { deriveStoreId } from '../domain/models/StoreIdentity'
 import { NativeStoreCatalogGateway } from '../infrastructure/engine/NativeStoreCatalogGateway'
@@ -66,53 +65,17 @@ class SmokeTest {
        return
      }
      this.reportOk('registry', `${String(stores.length)} store(s) from ${this.registry.sourceUrl}`)
      // The slug is worth printing: it names the store home and the games subfolder, and
      // it is derived here rather than told to us, so a wrong catalog URL shows up as a
      // wrong folder name before anything is installed.
      for (const store of stores) {
        this.reportOk(`  ${store.name}`, `${store.catalogUrl} · ${deriveStoreId(store)}`)
        await this.checkStoreConfig(store)
      }
    } catch (error: unknown) {
      this.reportBad('registry', `${this.registry.sourceUrl}: ${this.describe(error)}`)
    }
  }
  /**
   * Where this store's configuration would come from, in the order the installer asks.
   *
   * A store needs no config and no repository: either way the engine's defaults carry
   * it, so every absence here is reported rather than failed. What is worth seeing is
   * *which* source answered — a store still being configured by a repository is a store
   * that has not moved over to the registry yet.
   */
  private async checkStoreConfig (store: RegistryStore): Promise<void> {
    if (store.config !== null) {
      const subfolder = this.readSubfolder(store.config)
      this.reportOk('  config', `${String(Object.keys(store.config).length)} sections ` +
        `from the registry${subfolder === null ? '' : `, subfolder ${subfolder}`}`)
      return
    }
    if (store.storeRepositoryUrl === null) {
      this.reportOk('  config', 'none, and no repository — the engine defaults would be used')
      return
    }
    const url = `${store.storeRepositoryUrl.replace(/\/+$/, '')}/raw/branch/master/config.json`
    try {
      const config: unknown = JSON.parse(await this.httpClient.readText(url))
      const sections = typeof config === 'object' && config !== null ? Object.keys(config).length : 0
      this.reportOk('  config.json', `${String(sections)} sections from the repository ` +
        '(not yet moved to the registry)')
    } catch (error: unknown) {
      this.reportOk('  config.json', `absent (${this.describe(error)}) — defaults would be used`)
    }
  }
  /** The prune boundary, which is the field worth seeing at a glance. */
  private readSubfolder (config: Readonly<Record<string, unknown>>): string | null {
    const paths = config['paths']
    if (typeof paths !== 'object' || paths === null) return null
    const subfolder = (paths as Readonly<Record<string, unknown>>)['subfolder']
    return typeof subfolder === 'string' ? subfolder : null
  }
  private findStore (): InstalledStore | null {
    const sandbox = process.env['SMOKE_HOME']
    if (sandbox !== undefined && sandbox.length > 0) {
@@ -2,8 +2,6 @@
 export interface RegistryStoreDto {
  readonly name: string
  readonly catalogUrl: string
-  /** Null when the store has no repository of its own; the engine's defaults are then used. */
+  /** Derived from the catalog host, or the name — what the store will be called on disk. */
  readonly storeRepositoryUrl: string | null
  /** Derived from the repository, the catalog host or the name — what the store will be called on disk. */
  readonly storeId: string
 }
@@ -6,12 +6,13 @@
 */
 export const ENGLISH_MESSAGES = {
  appName: 'WarpEngine Client',
-  refresh: 'Refresh',
+  refresh: 'Refresh the catalog',
  install: 'Install',
-  update: 'Update',
+  upgrade: 'Upgrade',
  play: 'Play',
  open: 'Open',
-  remove: 'Remove',
+  uninstall: 'Uninstall',
  moreActions: 'More actions',
  installed: 'installed',
  native: 'native',
  hosted: 'hosted',
@@ -6,12 +6,13 @@ import type { MessageBundle } from './MessageBundle'
 */
 export const HUNGARIAN_MESSAGES: MessageBundle = {
  appName: 'WarpEngine Client',
-  refresh: 'Frissítés',
+  refresh: 'Katalógus frissítése',
  install: 'Telepítés',
-  update: 'Frissítés',
+  upgrade: 'Frissítés',
  play: 'Indítás',
  open: 'Megnyitás',
-  remove: 'Eltávolítás',
+  uninstall: 'Eltávolítás',
  moreActions: 'További műveletek',
  installed: 'telepítve',
  native: 'natív',
  hosted: 'hosztolt',