Merge pull request 'Release v1.14.1 — ansible certs-dir fix + Robokassa go-live' (#239) from development into master

.claude/CLAUDE.md

@@ -1,242 +0,0 @@
-# Agent field notes — scrabble-game
-
-Non-obvious, hard-won project knowledge that is **not** in the main docs (`CLAUDE.md`, `docs/*`,
-`deploy/README.md`). Kept in the repo so it travels with a clone to any host. These are working
-memory, not a spec — **verify any named file / flag / function against the current code before acting
-on it**, and prefer the authoritative docs where they overlap. Add to this file as new gotchas turn up.
-
-## Codegen & build
-
-- **jetgen churns everything.** `backend/cmd/jetgen` regenerates go-jet code for *all* tables and may
-  reorder output. After running it, revert the churn on tables you did not touch and commit only your
-  table's change.
-- **flatc is version-pinned** (`pkg/Makefile`, `REQUIRED_FLATC = 23.5.26`, hard-checked). A different
-  flatc silently churns the generated wire code and can flip wire defaults. Never regenerate FBS with
-  another flatc version.
-- **gopls lags codegen.** Right after an FBS/jet regen, gopls shows phantom "undefined" errors. Trust
-  `go build` / `go test`, not the editor squiggles.
-- **go-jet type mapping:** SQL `numeric` → `float64`, `interval` → `string`. Never store money as
-  `numeric` (float precision loss) — use **bigint minor units + a `Money` type**; store durations as
-  **int seconds**, not `interval`.
-- **`go mod tidy` chokes on dot-free local module paths** (`scrabble/...`). Hand-edit `go.mod` when a
-  bump is needed. The solver (`../scrabble-solver`) is consumed via `go.work` replace locally, but a
-  prod bump goes through a solver **PR → master + a published tag**, not a local replace.
-- **Run the whole CI suite locally before pushing** — unit + integration (`//go:build integration`,
-  Postgres) + the UI job + codegen check. Do not lean on CI to catch what a local run would.
-- **CI runner shares this host's `/tmp` as a different user.** In workflow steps, write artifacts to
-  `${GITHUB_WORKSPACE}`, never a fixed `/tmp/...` path (cross-user permission failures otherwise).
-- **pnpm corepack pre-flight flakes.** `pnpm exec` / `pnpm check` occasionally abort on a corepack
-  pre-flight. Dodge it by invoking the tool directly: `node_modules/.bin/<tool>`.
-
-## Native Android build (Capacitor)
-
-The native Android app is a Capacitor 8 wrapper of the `ui` SPA, scaffolded under
-`ui/` (a Node project outside `go.work`). Hard-won bring-up facts — verify against current code:
-
-- **Capacitor 8 needs JDK 21, not 17.** `@capacitor/android` compiles at `VERSION_21`; a JDK 17 Gradle
-  run dies with `error: invalid source release: 21`. Install sudo-free via the Homebrew **formula**
-  `brew install openjdk@21` (the `temurin@21` **cask** wants sudo for a system `.pkg`, unusable
-  non-interactively) + a user symlink into `~/Library/Java/JavaVirtualMachines/` so
-  `/usr/libexec/java_home -v 21` finds it. JDK 17 stays fine for `sdkmanager`/`avdmanager`.
-- **Cap 8 SDK pins:** compileSdk/targetSdk **36**, minSdk **24**, Gradle **8.14.3**, AGP **8.13.0**
-  (`ui/android/variables.gradle`). Install `platforms;android-36` — Android Studio's newer
-  `android-36.1` does NOT satisfy compileSdk 36.
-- **SDK is Android Studio's** at `~/Library/Android/sdk` (no `cmdline-tools` by default → `brew install
-  --cask android-commandlinetools`, then `sdkmanager`/`avdmanager --sdk_root=$HOME/Library/Android/sdk`).
-  Gradle finds it via **`ANDROID_HOME`** (`local.properties` is gitignored, machine-specific).
-- **Build recipe:** `cd ui && pnpm build && node_modules/.bin/cap sync android`; then `cd ui/android &&
-  ANDROID_HOME=~/Library/Android/sdk JAVA_HOME=$(/usr/libexec/java_home -v 21) ./gradlew assembleDebug`
-  → `ui/android/app/build/outputs/apk/debug/app-debug.apk`. Prefer the local `ui/node_modules/.bin/cap`
-  (dodges the corepack flake).
-- **Emulator smoke:** existing AVDs `Pixel_10` / `Pixel_4_Android_10_API_29` / `Pixel_Android_9`;
-  `emulator -avd <name>`, `adb install -r <apk>`, `adb shell monkey -p ru.eruditgame.app -c
-  android.intent.category.LAUNCHER 1`, `adb exec-out screencap -p > x.png`. The boot wait needs `sleep`
-  → run it as a **background** Bash task (foreground `sleep` is blocked). Browsers/WebView are cached, so a
-  full offline vs_ai turn is drivable via `adb shell input tap` (tap through the first-run coachmark tour —
-  each tap advances one step — then Hint places a suggested word; commit → the robot replies).
-- **Android 15+ edge-to-edge safe-area (WebView-version-dependent, bit me on API 37).** targetSdk 36 forces
-  edge-to-edge — the WebView draws behind the status bar (top) and the gesture-nav home indicator (bottom).
-  On Android **WebView < 140**, `env(safe-area-inset-*)` wrongly reports **0**, so chrome relying on it draws
-  under the bars and is untappable: the top nav under the clock, and the game's bottom action bar's **centre**
-  button (Hint) under the home-indicator pill (side buttons still work; `navigation_mode`=2 is gesture nav).
-  Fix is CSS-only, in TWO parts: (1) Capacitor 8's **SystemBars** plugin (built into `@capacitor/core`,
-  `insetsHandling:'css'` default — no dep, no config) injects correct `--safe-area-inset-*`; consume them as
-  `--tg-safe-*: var(--safe-area-inset-*, env(safe-area-inset-*, 0px))` (`ui/src/app.css`) — fixes any consumer
-  that ALREADY applies the token (the bottom bars: `Game.svelte`/`Screen.svelte` `--tg-safe-bottom`).
-  (2) But a consumer that never applied the top inset on the native path is NOT fixed by the token alone — the
-  **header's** top inset was Telegram-fullscreen-scoped only, so the native header sat under the status bar on
-  EVERY WebView; it needed its own `.bar { padding-top: calc(var(--safe-area-inset-top, 0px) + 5px) }`
-  (`Header.svelte`, native-only via the plugin var; tg-fullscreen still overrides via specificity). **Measure
-  per element, don't eyeball** — a centred title at y=11 under a 54px bar reads as "fine" in a screenshot but
-  is overlapping; an emulator WebView auto-updated to ≥140 (Chrome 149) also hides the `env()`=0 half (so the
-  BOTTOM looks fine there while the user's < 140 device overlaps). **Inspect a live debug WebView** over CDP:
-  `adb forward tcp:9222 localabstract:$(adb shell cat /proc/net/unix | grep -o 'webview_devtools_remote_[0-9]*'
-  | head -1)`, then Playwright `chromium.connectOverCDP('http://localhost:9222')` → `page.evaluate` (read each
-  element's `getBoundingClientRect().top`, and `--safe-area-inset-*` vs `env(...)`).
-- **`sharp` is whitelisted** in `ui/pnpm-workspace.yaml` (`allowBuilds: sharp: true`) — `@capacitor/assets`
-  uses it for `pnpm android:assets` (launcher icon/splash); else pnpm 11 raises `ERR_PNPM_IGNORED_BUILDS`.
-- **Bundled offline dicts come from the `scrabble-dictionary` release** (`scrabble-dawg-<DICT_VERSION>.tar.gz`,
-  keyed on the `DICT_VERSION` Gitea var — the same source the backend image + CI `curl`), NOT
-  `scrabble-solver/dawg` (those are the solver's pinned test fixtures).
-
-## Wire / schema evolution (client ↔ gateway ↔ backend)
-
-- **FBS is additive-only.** Add **trailing** fields ("added trailing — backward-compatible"). Never
-  delete or reorder a mid-table field — **deprecate** it (`(deprecated)`); deleting shifts field IDs
-  and breaks older readers.
-- **Retiring a domain field must also retire the WIRE field it fed** — by deprecation, not deletion,
-  and do not just zero it: a dead `0` the client dutifully syncs will clobber the real value.
-- **The gateway transcodes FBS ↔ backend JSON DTOs in lockstep.** A wire change usually means editing
-  both the FBS schema and the backend DTO.
-- **Seat display name is built in two places** — `game.Service` live events **and** the server REST
-  DTOs. Change both or they drift.
-- **A per-viewer flag is computed only in the per-viewer REST DTO**; the client seeds it from REST,
-  then bumps it from the live event. Don't expect it on the shared broadcast.
-
-## UI / Svelte 5
-
-- **Never name a `$state` variable `state`.** `svelte-check` then misreads `$state` as a store
-  subscription. Rename (e.g. `view`).
-- **Svelte trims literal edge whitespace** in markup. To keep a separator space, emit an expression:
-  `{' : '}`.
-- **No global `.btn` / `.ghost` button classes.** Style buttons per-component with scoped CSS + design
-  tokens (mirror `NewGame`'s `.invite`).
-- **A `$state` proxy fails structured-clone** when persisted to IndexedDB. Snapshot at the call site
-  with `$state.snapshot(...)` before storing.
-
-## Platform / WebView quirks (Telegram, VK, iOS, native, old Android)
-
-- **Telegram `showPopup` eats the user-activation.** Share / clipboard called from inside a
-  `showPopup` callback fail (no gesture). Use your own `Modal` for gesture-gated Web APIs.
-- **iOS Telegram `<a download blob:>` navigates away** and strands the SPA. Deliver files by **Web
-  Share on mobile**, and only use a `<a download>` Blob path on **desktop**.
-- **Android TG/VK WebViews** lack `navigator.share` and ignore `<a download>`. Deliver a
-  client-generated file by **copying it to the clipboard**.
-- **VK Android WebView ignores `target=_blank`.** Open external links through `lib/links.ts`
-  (routes to `vk.com/away.php`). Verify on-device.
-- **Per-platform file-delivery last hop differs** (TG / VK / plain browser) — there is a delivery
-  matrix; do not re-litigate it without new on-device facts.
-- **Old Android System WebView floor ≈ Chrome 67.** The bundle targets **es2019** (esbuild lowers
-  syntax), a conditional `core-js` polyfill loads only on old engines, and `index.html` has a boot
-  gate (BigInt / Proxy are the hard block → the unsupported-engine screen). There's also a `vmin`
-  glyph fallback for old rendering.
-- **iOS WKWebView overscroll and Telegram swipe-to-close are not reproducible in Playwright.** Verify
-  those live on the deployed contour, not in the e2e.
-- **Telegram Desktop Mini App shows a persistent bottom-right loader** — that's the long-lived
-  Subscribe stream, cosmetic, deliberately left as-is.
-
-## Testing
-
-- **UI test layers:** vitest (node env, pure logic, **no jsdom**) + Playwright **mock** e2e. The mock
-  e2e **bypasses the codec**, so wire/codec bugs need **codec unit tests**, not e2e coverage.
-- **Mock overlay blocks e2e.** The cold-load overlay must be instant under the mock build or it
-  intercepts Playwright taps.
-- **Mock tile pools lack a blank `'?'`.** The seeded game `G1` hard-codes one; flip `G1`'s variant to
-  eyeball per-variant tiles.
-- **Durable Playwright MCP servers** (chromium + webkit) exist for UI inspection (there's a
-  plugin-config gotcha in wiring them).
-- **The `playwright test` runner can't *fetch* browsers in this sandbox** — `playwright install` dies
-  with `EBADF` against the Playwright CDN (blocked network), even with the sandbox off. Run the e2e in
-  **CI** (the `ui` job installs chromium+webkit), or drive a state live through the **Playwright MCP**
-  browser against a local `vite --mode mock` server for visual verification. **But if chromium/webkit are
-  already cached** in `~/Library/Caches/ms-playwright/`, `playwright test` runs locally fine (only the CDN
-  fetch is blocked) — the native offline-first e2e was run green locally this way (chromium + webkit),
-  its dawgs from the sibling `../../scrabble-solver/dawg` via the webServer's `bundle-dicts.mjs` fallback.
-- **A native (Capacitor) e2e must inject `window.androidBridge`, NOT `window.Capacitor.getPlatform`.**
-  `@capacitor/core` (pulled in during boot by `initNativeShell`'s dynamic `@capacitor/app` import)
-  **replaces** any pre-set `window.Capacitor` with its own shim and derives the platform from
-  `window.androidBridge` (android) / `window.webkit.messageHandlers` (ios) — so a bare injected
-  `Capacitor.getPlatform: () => 'android'` is clobbered to `web` and the boot falls to `/login`. Inject
-  `window.androidBridge = { postMessage(){} }` in an `addInitScript` (see `e2e/native.spec.ts` `simulateNative`);
-  `initNativeShell` is written to tolerate the stub bridge (`try/catch` round the `@capacitor/app` addListener).
-- **`docker run -p ...` boot tests fail from the shell** (published ports unreachable in this env).
-  Use **testcontainers** for container-backed tests.
-- **Distroless images run as UID 65532 (nonroot).** Bind-mounted TLS keys must be **0644** (not 0600)
-  or the service crash-loops on start.
-
-## Deploy / test contour (operational)
-
-- **The TEST contour runs on THIS dev host.** Inspect it via `docker` / Prometheus. A host-side
-  `curl` to caddy **hangs** (NAT hairpin) — don't debug the edge that way.
-- **The contour's client IP is the home-router SNAT address**, not the real external IP. Correct in
-  prod, not a bug — which is why the IP ban / blocklist are **prod-only**.
-- **The contour is one shared env, last-deploy-wins.** Keep a multi-PR batch a **linear stack** (one
-  PR, one deploy) so deploys don't clobber each other.
-- **A schema/wire PR breaks the contour** until a `DROP SCHEMA` + backend restart. Note such a
-  prerelease step in `PRERELEASE.md`.
-- **A contour DB wipe resets the account but not the client's stored locale**; the reconciler then
-  syncs the stale locale, masking a fresh TG `language_code` seed. Clear client prefs too when testing
-  locale.
-- **`DNS=` in `TEST_AWG_CONF` pins the VPN netns to 1.1.1.1** → internal names go NXDOMAIN → the
-  bot-link silently dies. Diagnose from inside the netns.
-- **Swap one contour service to a local image** without deploy secrets via a busybox-in-the-netns
-  socket-inspect trick (single-service recreate).
-- **A rolling deploy did NOT recreate caddy on a config-only change.** Force `--force-recreate` for
-  caddy; don't trust "deploy green" for an edge-config change.
-- **A new gateway edge route MUST be added to the Caddyfile `@gateway` matcher** or it falls through
-  to the landing catch-all. Add a CI probe for the route.
-- **Prod caddy logs warnings only, no access log.** Trace a request via the backend "http request"
-  telemetry log or Tempo, not caddy.
-- **Confirm a release is live without SSH** by grepping the served SPA: `__APP_VERSION__` inside
-  `/assets/main-*.js`.
-- **"App hangs on load" was a dead HTTP/3 advert:** caddy sent `Alt-Svc: h3` with no UDP/443 open;
-  clients cache it ~30 days. Fix with `Alt-Svc: clear`.
-- **Config-poison deploy loop:** a crash-looping config-mounted service + a missing bind source
-  produces a root-owned directory that then fails deploys. Break it by removing the root-owned dir.
-- **Maintenance-window contract** (planned-deploy 503): a marker header, `/_gm` exempt, the flag spans
-  the whole roll, the SPA overlay reloads on recovery. Don't break these invariants.
-- **A new dictionary goes live via a `/_gm/dictionary` upload, NOT a redeploy.** In-flight games keep
-  their pinned version. The **owner** does the upload.
-- **Renderer deploy job flakes** on the skia-canvas GitHub binary download when its lockfile changes —
-  re-run, it's not your code.
-
-## Repo workflow
-
-- **PR-based, zero issues.** Work is tracked via PRs + `PRERELEASE.md`. "заведи задачу" means *do it*
-  / add a plan line — not file a tracker issue.
-- **`tea` CLI for all Gitea ops** (PRs, secrets, variables, dispatch). `gh` does **not** work here. The
-  agent **cannot self-approve** a PR but **can merge** it after the owner approves. Watch the
-  stale-mergeable trap (re-check mergeability right before merging).
-- **Watch every push/merge/deploy to green** with `python3 ~/.claude/bin/gitea-ci-watch.py`, launched
-  **bare** under a background task. It polls run-level conclusions; its `ALL GREEN` already covers the
-  gated deploy job. Pass `--no-runs 600` when the runner is busy. A **merge** is the most-forgotten
-  case — watch the post-merge runs too.
-- **After a merge, switch to the merged-into branch** (`development`/`master`), pull, and prune the
-  local feature branch.
-- **The contour deploy probe checks the backend `/readyz`**; a PR deploy builds the PR's own code; a
-  wedged contour can be recovered by recreating the host container set.
-
-## Domain semantics (not obvious from the code)
-
-- **Account deletion must NOT delete any user messages** — including feedback / support. Interview the
-  owner on every deletion point before wiring it.
-- **`account.time_zone` is `NOT NULL DEFAULT 'UTC'`, seeded from a detected ±HH:MM offset.** An email
-  account row is created at the **code-request** step, not at confirmation.
-- **The robot has two distinct time windows:** a **sleep window** (~00:00–07:00, gates its moves and
-  nudges) vs the **player away window** (turn-timeout only). "окно отсутствия" in dialogue = the
-  **sleep** window.
-
-## Production topology
-
-- **Two prod hosts.** `main` — full stack + ACME/edge (Selectel); `tg` — Telegram bot only (vdsina).
-  SSH aliases `scrabble-main-ops` / `scrabble-tg-ops`. Deploy is **manual dispatch only**, rolling +
-  health-gated + auto-rollback. Hosts are provisioned by `deploy/ansible/` (inventory + vars there —
-  the source of truth for IPs/roles).
-- **The agent has targeted root SSH** to the hosts (and may run the prod Ansible). Surface every
-  owner-side step **before** a deploy, not after.
-
-## Feature-area pointers (state lives in the linked docs/plans, not here)
-
-- **Monetization** — «Фишка» currency, per-platform wallets, ads. Agreements in
-  `docs/PAYMENTS_DECISIONS_ru.md`; a phased plan (E0–E9). go-jet money rule above applies.
-- **PITR** — pgBackRest → Selectel S3 (encrypted, 30-day), currently **gated off**; runbook in
-  `deploy/README.md`. Gotcha: run pgBackRest via docker-exec **as the `postgres` user** with
-  `--pg1-user=scrabble`.
-- **Offline mode** — the robot brain, move generator/validator/scorer and DAWG reader are **JS ports**
-  of the Go engine, bundled client-side and **parity-pinned** by golden tests. Multi-phase; native
-  offline-first bundles the dictionaries.
-- **VK ID web login** — raw OAuth 2.1 against `id.vk.com`, a **separate VK "Web" app** from the Mini
-  App, server-side confidential code exchange.
-- **Email relay** — Selectel SMTP + confirm / link / unlink / deletion codes + alerts.
-- **Native Android** — Capacitor bundle model, client-version gate, offline-first, RuStore; the
-  design lives in `docs/ARCHITECTURE.md` (§2 gate, §3 identity, §13 native build).

.gitea/workflows/android-build.yaml

@@ -1,172 +0,0 @@
-# Manual signed-APK build for the standalone Android app (RuStore). Runs ONLY from master, ONLY on
-# workflow_dispatch with confirm=build — the same deliberate-manual shape as prod-deploy.yaml, never on
-# a PR. It builds the native-flavoured SPA, bundles the offline dictionaries into the APK assets, and
-# assembles a release APK, uploaded as a run artifact (RuStore upload stays manual for the MVP).
-#
-# Signing degrades gracefully: with the ANDROID_RUSTORE_* secrets present the APK is signed; without
-# them build.gradle produces an UNSIGNED release APK (so a dry run still proves the whole pipeline).
-# The keystore is a publication prerequisite — see deploy/README.md (Android build/release runbook).
-# The toolchain is self-provisioned here (JDK 21 + a cached Android SDK), so the runner host needs
-# nothing pre-installed.
-name: android-build
-run-name: "android build ${{ github.sha }}"
-
-on:
-  workflow_dispatch:
-    inputs:
-      confirm:
-        description: 'Type "build" to confirm an APK build from master.'
-        required: true
-        default: ""
-
-permissions:
-  contents: read
-
-env:
-  NO_COLOR: "1"
-  # The dictionary release, one source of truth (same Gitea variable the backend image + CI use). It
-  # both fetches the DAWGs and labels the bundled files (VITE_DICT_VERSION must equal __DICT_VERSION__).
-  DICT_VERSION: ${{ vars.DICT_VERSION }}
-  VITE_DICT_VERSION: ${{ vars.DICT_VERSION }}
-  # Hide in-app purchases in the RuStore MVP (RuStore, not Google Play — VITE_GP_BUILD stays unset).
-  VITE_PAYMENTS_DISABLED: "1"
-  # The update overlay's store target; empty until publication (the button no-ops, and the version gate
-  # is dormant in the MVP so it never fires). Set the ANDROID_RUSTORE_URL variable when the app is live.
-  VITE_RUSTORE_URL: ${{ vars.ANDROID_RUSTORE_URL }}
-  # Host-executor runner: the Android SDK is pre-installed on the host. Override ANDROID_SDK_DIR if it
-  # lives elsewhere (the default matches deploy/README.md's install path).
-  ANDROID_HOME: ${{ vars.ANDROID_SDK_DIR || '/opt/android-sdk' }}
-  ANDROID_SDK_ROOT: ${{ vars.ANDROID_SDK_DIR || '/opt/android-sdk' }}
-
-jobs:
-  build:
-    if: ${{ github.ref == 'refs/heads/master' && inputs.confirm == 'build' }}
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      # Host-executor runner: the Android SDK is pre-installed on the host (JDK 21 comes from setup-java
-      # below). Fail fast + legibly if the runner user cannot read/execute it or a needed package is
-      # missing — this doubles as the runner-access check (deploy/README.md).
-      - name: Verify the host Android SDK
-        run: |
-          sm="$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager"
-          if [ ! -x "$sm" ]; then
-            echo "::error::sdkmanager not found/executable at $sm — set the ANDROID_SDK_DIR variable if the SDK lives elsewhere, or grant the runner user read+exec: sudo chmod -R a+rX \"$ANDROID_HOME\""; exit 1
-          fi
-          for pkg in "platforms/android-36" "build-tools"; do
-            if [ ! -d "$ANDROID_HOME/$pkg" ]; then
-              echo "::error::missing $ANDROID_HOME/$pkg — run: \"$sm\" 'platforms;android-36' 'build-tools;36.0.0'"; exit 1
-            fi
-          done
-          echo "Android SDK OK at $ANDROID_HOME"; "$sm" --version
-
-      - name: Compute version + native build env
-        id: prep
-        env:
-          PUBLIC_BASE_URL: ${{ vars.PROD_PUBLIC_BASE_URL }}
-        run: |
-          # A store release must sit on an exact vMAJOR.MINOR.PATCH tag (G tags before dispatch) so the
-          # versionCode is deterministic and strictly increasing across uploads. Refuse anything else
-          # rather than derive a versionCode from a "-N-gSHA" describe.
-          desc="$(git describe --tags --exact-match 2>/dev/null || true)"
-          case "$desc" in
-            v[0-9]*.[0-9]*.[0-9]*) ;;
-            *) echo "::error::HEAD is not on a clean vX.Y.Z tag (git describe --exact-match = '${desc:-none}'); tag the release first"; exit 1 ;;
-          esac
-          v="${desc#v}"
-          IFS=. read -r MA MI PA <<< "$v"
-          # 10# forces base-10 so a zero-padded part is never read as octal.
-          code=$(( 10#$MA * 1000000 + 10#$MI * 1000 + 10#$PA ))
-          # The native SPA talks to the production origin (reuse the prod public base URL); strip any
-          # trailing slash so the Connect endpoint never doubles it.
-          gateway="${PUBLIC_BASE_URL%/}"
-          {
-            echo "tag=$desc"
-            echo "name=$v"
-            echo "code=$code"
-            echo "gateway=$gateway"
-          } >> "$GITHUB_OUTPUT"
-          echo "release $desc -> versionName $v versionCode $code, gateway $gateway"
-
-      # Same release + fetch as the Go/UI jobs in ci.yaml — the bundled dicts come from this tarball,
-      # NOT the scrabble-solver sibling (ui is a Node project outside go.work).
-      - name: Fetch dictionary DAWGs
-        run: |
-          mkdir -p "${GITHUB_WORKSPACE}/dawg"
-          curl -fsSL -o /tmp/dawg.tar.gz "https://gitea.iliadenisov.ru/developer/scrabble-dictionary/releases/download/${DICT_VERSION}/scrabble-dawg-${DICT_VERSION}.tar.gz"
-          tar xzf /tmp/dawg.tar.gz -C "${GITHUB_WORKSPACE}/dawg"
-          ls -la "${GITHUB_WORKSPACE}/dawg"
-
-      - name: Set up Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-
-      - name: Install pnpm
-        run: npm install -g pnpm@11.0.9
-
-      - name: Install deps
-        working-directory: ui
-        run: pnpm install --frozen-lockfile
-
-      - name: Build the SPA (native flavour)
-        working-directory: ui
-        env:
-          VITE_GATEWAY_URL: ${{ steps.prep.outputs.gateway }}
-          VITE_APP_VERSION: ${{ steps.prep.outputs.tag }}
-        run: pnpm run build
-
-      # Copy the release DAWGs into dist/dict/<variant>@<version>.dawg for the offline-first bundled tier
-      # (after the build, before cap sync copies dist/ into the native assets).
-      - name: Bundle the dictionaries
-        working-directory: ui
-        env:
-          DICT_DIR: ${{ github.workspace }}/dawg
-        run: node scripts/bundle-dicts.mjs
-
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          distribution: temurin
-          java-version: "21"
-
-      # Local cap binary (dodges the corepack pre-flight flake); syncs dist/ (incl. dict/) + native deps.
-      - name: Sync the native project
-        working-directory: ui
-        run: node_modules/.bin/cap sync android
-
-      - name: Decode the release keystore
-        id: keystore
-        env:
-          ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_RUSTORE_KEYSTORE_BASE64 }}
-        run: |
-          if [ -n "$ANDROID_KEYSTORE_BASE64" ]; then
-            printf '%s' "$ANDROID_KEYSTORE_BASE64" | base64 -d > "${GITHUB_WORKSPACE}/release.jks"
-            echo "file=${GITHUB_WORKSPACE}/release.jks" >> "$GITHUB_OUTPUT"
-            echo "keystore decoded -> signed release build"
-          else
-            echo "file=" >> "$GITHUB_OUTPUT"
-            echo "::warning::ANDROID_RUSTORE_KEYSTORE_BASE64 secret is not set — building an UNSIGNED release APK (not installable/publishable)"
-          fi
-
-      - name: Assemble the release APK
-        working-directory: ui/android
-        env:
-          ANDROID_KEYSTORE_FILE: ${{ steps.keystore.outputs.file }}
-          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_RUSTORE_KEYSTORE_PASSWORD }}
-          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_RUSTORE_KEY_ALIAS }}
-          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_RUSTORE_KEY_PASSWORD }}
-        run: ./gradlew assembleRelease -PversionCode=${{ steps.prep.outputs.code }} -PversionName=${{ steps.prep.outputs.name }} --console=plain
-
-      - name: Upload the APK artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: erudit-${{ steps.prep.outputs.name }}-apk
-          path: ui/android/app/build/outputs/apk/release/*.apk
-          if-no-files-found: error

.gitea/workflows/ci.yaml

@@ -353,11 +353,6 @@ jobs:
           # for the server-side confidential code exchange — a SEPARATE VK app from the Mini
           # App above. One VK ID "Web" app serves every contour -> unprefixed secret.
           GATEWAY_VK_ID_CLIENT_SECRET: ${{ secrets.GATEWAY_VK_ID_CLIENT_SECRET }}
-          # Client-version gate (ARCHITECTURE.md §2): one plain (unprefixed) variable serves every
-          # contour. In the test contour the stamped client version is a commit hash (unparseable ⇒
-          # fail-open), so setting these only enforces on real semver prod builds. Empty ⇒ dormant.
-          GATEWAY_MIN_CLIENT_VERSION: ${{ vars.GATEWAY_MIN_CLIENT_VERSION }}
-          GATEWAY_RECOMMENDED_CLIENT_VERSION: ${{ vars.GATEWAY_RECOMMENDED_CLIENT_VERSION }}
           # Planted honeytoken bearer: presenting it flags the caller (logs + a ban metric on
           # test where the IP ban is off; a 24h IP ban on prod). Per-contour secret; empty = trap off.
           GATEWAY_HONEYTOKEN: ${{ secrets.TEST_GATEWAY_HONEYTOKEN }}
@@ -515,64 +510,19 @@ jobs:
       - name: Probe the /offer/ public offer page is served
         run: |
           set -u
-          # /offer/ is rendered by the render sidecar: it splices the live catalog price list
+          # /offer/ is a static page baked into the landing image (rendered from
-          # (fetched from the backend's internal endpoint) into the committed ui/legal/offer_ru.md.
+          # ui/legal/offer_ru.md). If the landing Caddyfile stops routing it, the request
-          # If the @offer caddy route is missing, the request falls to the landing shell (also 200),
+          # silently falls through to the landing shell (also 200) — so assert offer-specific
-          # and if the backend fetch fails the sidecar returns 502 — so assert offer-specific content
+          # content, never just the status.
-          # (the seller INN, §11) AND that the pricing marker was substituted (proves the fetch +
+          out="$(docker run --rm --network edge alpine:3.20 wget -q -O - http://scrabble/offer/ 2>&1 || true)"
-          # splice ran), never just the status. Data-independent: an empty catalog still substitutes
+          if echo "$out" | grep -q "290210610742"; then
-          # the marker with nothing, so "pricing_template" must be absent either way.
+            echo "ok: /offer/ serves the public offer page"
-          # Full body is needed (the INN is in §11 and the marker check spans the page), so this
+          else
-          # cannot be a head-only probe like the legal one. Retry with a timeout instead: the offer is
+            echo "FAIL: /offer/ did not serve the offer page (fell through to the landing shell?)"
-          # now bilingual (RU + EN, larger), and a single-shot fetch can race the renderer's restart in
-          # the same deploy.
-          ok=
-          for i in $(seq 1 20); do
-            out="$(docker run --rm --network edge alpine:3.20 wget -q -T 10 -O - http://scrabble/offer/ 2>&1 || true)"
-            if echo "$out" | grep -q "290210610742" && ! echo "$out" | grep -q "pricing_template"; then
-              echo "ok: /offer/ serves the rendered offer with the price list spliced in"
-              ok=1
-              break
-            fi
-            sleep 3
-          done
-          if [ -z "$ok" ]; then
-            echo "FAIL: /offer/ did not serve the rendered offer (route fell through, or the price splice failed)"
-            docker logs --tail 50 scrabble-renderer || true
-            docker logs --tail 50 scrabble-backend || true
             docker logs --tail 50 scrabble-landing || true
             exit 1
           fi
 
-      - name: Probe the /privacy/ and /eula/ legal pages are served
-        run: |
-          set -u
-          # /privacy/ and /eula/ are static legal markdown rendered by the render sidecar. If the
-          # @legal caddy route is missing they fall to the landing shell (also 200, canonical
-          # erudit-game.ru/), so assert the page-specific canonical URL — it uniquely identifies the
-          # rendered legal doc reaching the edge, not the landing catch-all. Read only the <head>
-          # (head -c 4096; the canonical link sits in the first bytes): the check is then
-          # size-independent, so the large EULA page does not exceed the timeout while the monitoring
-          # stack is still booting post-deploy and starving the CPU-capped renderer. Retry like the
-          # landing/gateway/backend probe to ride out that window.
-          for route in privacy eula; do
-            ok=
-            for i in $(seq 1 20); do
-              head_out="$(docker run --rm --network edge alpine:3.20 sh -c "wget -q -T 10 -O - http://scrabble/${route}/ 2>/dev/null | head -c 4096" || true)"
-              if printf '%s' "$head_out" | grep -qF "erudit-game.ru/${route}/"; then
-                echo "ok: /${route}/ serves the rendered legal page"
-                ok=1
-                break
-              fi
-              sleep 3
-            done
-            if [ -z "$ok" ]; then
-              echo "FAIL: /${route}/ did not serve the rendered legal page (@legal route missing?)"
-              docker logs --tail 50 scrabble-renderer || true
-              exit 1
-            fi
-          done
-
       - name: Probe the /pay/ callback route reaches the gateway
         run: |
           set -u

.gitea/workflows/prod-deploy.yaml

@@ -112,20 +112,9 @@ jobs:
       # derived from PUBLIC_BASE_URL in deploy/write-prod-env.sh.
       VITE_VK_APP_ID: ${{ vars.VITE_VK_APP_ID }}
       GATEWAY_VK_ID_CLIENT_SECRET: ${{ secrets.GATEWAY_VK_ID_CLIENT_SECRET }}
-      # Client-version gate (ARCHITECTURE.md §2): plain (unprefixed) vars, shared across contours
-      # (empty ⇒ dormant). On prod the stamped client version is a real semver, so the gate enforces
-      # here — set GATEWAY_MIN_CLIENT_VERSION to the release in the same rollout that ships a breaking
-      # wire change; bump GATEWAY_RECOMMENDED_CLIENT_VERSION (≥ min) to nudge upgrades softly.
-      GATEWAY_MIN_CLIENT_VERSION: ${{ vars.GATEWAY_MIN_CLIENT_VERSION }}
-      GATEWAY_RECOMMENDED_CLIENT_VERSION: ${{ vars.GATEWAY_RECOMMENDED_CLIENT_VERSION }}
       # Planted honeytoken bearer: presenting it earns a 24h IP ban + a high-severity alarm.
       # Per-contour secret; empty = trap off. Rendered by deploy/write-prod-env.sh.
       GATEWAY_HONEYTOKEN: ${{ secrets.PROD_GATEWAY_HONEYTOKEN }}
-      # Community IP blocklist (Spamhaus DROP): opt-in. Set _ENABLED=true + _URL (the feed) once
-      # verified; _ALLOW is a comma-separated never-block set (own infra). Empty ⇒ off.
-      GATEWAY_BLOCKLIST_ENABLED: ${{ vars.PROD_GATEWAY_BLOCKLIST_ENABLED }}
-      GATEWAY_BLOCKLIST_URL: ${{ vars.PROD_GATEWAY_BLOCKLIST_URL }}
-      GATEWAY_BLOCKLIST_ALLOW: ${{ vars.PROD_GATEWAY_BLOCKLIST_ALLOW }}
       # Signs the finished-game export download URLs (backend BACKEND_EXPORT_SIGN_KEY).
       EXPORT_SIGN_KEY: ${{ secrets.PROD_EXPORT_SIGN_KEY }}
       # Transactional email via the shared Selectel relay (confirm-codes): one account for

.gitea/workflows/prod-rollback.yaml

@@ -70,10 +70,6 @@ jobs:
       VITE_VK_APP_ID: ${{ vars.VITE_VK_APP_ID }}
       GATEWAY_VK_ID_CLIENT_SECRET: ${{ secrets.GATEWAY_VK_ID_CLIENT_SECRET }}
       GATEWAY_HONEYTOKEN: ${{ secrets.PROD_GATEWAY_HONEYTOKEN }}
-      # Community IP blocklist — rendered on rollback too so a rollback keeps the same edge policy.
-      GATEWAY_BLOCKLIST_ENABLED: ${{ vars.PROD_GATEWAY_BLOCKLIST_ENABLED }}
-      GATEWAY_BLOCKLIST_URL: ${{ vars.PROD_GATEWAY_BLOCKLIST_URL }}
-      GATEWAY_BLOCKLIST_ALLOW: ${{ vars.PROD_GATEWAY_BLOCKLIST_ALLOW }}
       EXPORT_SIGN_KEY: ${{ secrets.PROD_EXPORT_SIGN_KEY }}
       SMTP_RELAY_USER: ${{ secrets.SMTP_RELAY_USER }}
       SMTP_RELAY_PASS: ${{ secrets.SMTP_RELAY_PASS }}

CLAUDE.md

@@ -156,11 +156,3 @@ The `ui` module is a Node project (pnpm), **not** in `go.work`; it is the `ui` j
 the single `.gitea/workflows/ci.yaml`. Committed edge codegen under `ui/src/gen/`
 (regenerate with `pnpm codegen`); pnpm build-script approval lives in
 `ui/pnpm-workspace.yaml` (`allowBuilds: esbuild: true`).
-
-## Agent field notes
-
-Non-obvious, hard-won knowledge the agent has accumulated that is **not** captured in the docs above,
-kept in the repo so it travels with a clone. Verify any named file/flag against current code before
-acting on it.
-
-@.claude/CLAUDE.md

PLAN.md

@@ -39,13 +39,10 @@ status — without re-deriving decisions.
 | E7 | Admin, reports & catalog | 2 | DONE |
 | E8 | Guest limits | — | DONE |
 | E9 | Tournament fee | future | TODO |
-| E10 | Multi-shop direct rail + ИП fiscalization | 2+ | DONE |
-| E11 | Payment availability kill switch + per-account override | 2 | DONE |
 
 **Release 1** = full mechanics with no real money, exercised via `admin_grant` (E0→E1→E2→E3).
 **Release 2** = money (E4→E5→E6→E7). E8 is standalone (game-behaviour change, can run in
-parallel). E9 is future. E10 splits the `direct` rail into per-channel Robokassa shops + ИП
+parallel). E9 is future.
-fiscalization (post-launch, backend-first).
 
 ---
 
@@ -895,123 +892,6 @@ tournament-entry storage + pricing design.
 
 ---
 
-## E10 — Multi-shop direct rail + ИП fiscalization
-
-**Status:** DONE (merged — the multi-shop PR) · **Release 2+ (post-launch, backend-first)** · depends on: E5 (intake/`Fund`,
-the `robokassa` adapter, the Result callback), E7 (the per-user report — channel breakdown) ·
-mechanics: PAYMENTS §9, §12; decisions D41 (rev), D42–D44.
-
-**Goal.** Split the single Robokassa `direct` rail into **per-channel merchant shops** (web,
-android; ios later) — separate merchant accounts / withdrawal / accounting and a per-channel
-breakdown in the E7 report — while keeping **one `direct` wallet** (D42). Land the wallet/identity
-rules the native apps need (email-only anchor, D43) and revise fiscalization for the owner's move
-to **ИП / 54-ФЗ** (D41 rev). All **additive / contour-safe** and **money-live** → expand-contract
-throughout.
-
-**Locked decisions (owner interview 2026-07-14): D41 (rev), D42, D43, D44.** No wallet-model /
-spend-wall change; the split is merchant-account routing under one `direct` segment. Route the shop
-by the **trusted** `X-Platform` subtype, never a client field; unknown → `web`.
-
-**B1 — Config: one shop → a set of shops.**
-
-- `robokassa.Config` (single) → a **shops registry** keyed by channel (`web`, `android`; `ios`
-  later), each 4 fields (`MerchantLogin`/`Password1`/`Password2`/`IsTest`). New env
-  `BACKEND_ROBOKASSA_WEB_*`, `BACKEND_ROBOKASSA_ANDROID_*`.
-- **Expand-contract, no flag-day:** the legacy `BACKEND_ROBOKASSA_*` seeds the `web` shop; add the
-  new vars; retire the legacy set after the prod rollout sets the split vars. `validate()`: a shop
-  with a login must carry both passwords (mirror the current check), per shop.
-- Config/README + `deploy/.env.example` + the deploy ansible vars.
-
-**B2 — Route the shop by channel (intake).**
-
-- `handleWalletOrder` `SourceDirect` branch: pick the shop by `cxt.Subtype` (`web`/`android`;
-  unknown → `web`). Build the payment request from that shop. The subtype rides the trusted
-  gateway-injected `X-Platform` (`<kind>/<subtype>`, `parsePlatformHeader`) — no spoofable client
-  field. **Verify the gateway emits `direct/android` for the native build**; if it sends a bare
-  `direct/`, add the android subtype (small gateway change).
-- Record the chosen `shop` on the order (feeds B5).
-
-**B3 — Per-shop Result callbacks.**
-
-- The callback must select the right `Password2` → each shop gets its own Result URL:
-  **per-shop public edge routes** (mirror the existing single Robokassa Result route, e.g.
-  `…/result/web`, `…/result/android`), each forwarded to the backend and verified with that shop's
-  config, then the same `Fund` (source stays `direct`). Add the routes to the **Caddyfile
-  `@gateway` matcher** (else they fall to the landing catch-all) **+ a CI probe per route**.
-- Keep the legacy single route alive (shop = `web`) through the expand-contract window until the
-  cabinet Result URLs are cut over.
-
-**B4 — ИП fiscalization (D41 rev) — RESOLVED (owner 2026-07-14): cabinet-side only.** The owner keeps
-Robokassa's cabinet auto-fiscalization (a generic чек is acceptable for the ИП); the optional
-itemized-`Receipt` / `Email` code below is **dropped** — not needed. (Kept for context.)
-
-- **Owner/cabinet:** enable the 54-ФЗ cloud kassa in the Robokassa ЛКК (kassa + ОФД + СНО).
-  Required for ИП regardless of code.
-- **Code (optional, itemized чеки):** send a one-line `Receipt` (pack name, qty 1, `sum`, `tax`
-  per СНО, `payment_object`/`payment_method`) + the customer `Email` (the D36 confirmed anchor) in
-  the payment request; extend the signature to `MerchantLogin:OutSum:InvId:Receipt:Password1`
-  (URL-encode `Receipt`). One line fits the current GET redirect; POST-form only as a URL-length
-  fallback. One feature, all shops. **Sequenced last** — the split (B1–B3, B5, B6) needs no
-  fiscalization. Supersedes the E5 §12 shop-side НПД receipt note.
-
-**B5 — Channel in the report (D44).**
-
-- Additive `shop` column on the order (default `web` / backfill from `origin`); a per-channel
-  breakdown in the E7 per-user report (D40). Expand-contract migration (nullable/defaulted column),
-  **contour-safe** (a schema touch → note the contour `DROP SCHEMA` step in `PRERELEASE.md`).
-
-**B6 — Tests + docs.**
-
-- unit: the `robokassa` shops registry + per-shop `VerifyResult` (right `Password2`);
-  signature-with-`Receipt` (B4); intake shop routing by subtype (web/android/unknown→web).
-- integration: order→per-shop callback→credit (each route), a duplicate credits once, an expired
-  order still honoured; the `shop` recorded + reported.
-- docs: `PAYMENTS.md` (+`_ru`) the multi-shop topology + the ИП/54-ФЗ receipt revision;
-  `deploy/README` + `.env.example` the new vars + the per-shop Result routes + probes;
-  `PRERELEASE.md` the `shop` column contour step.
-
-**Done-criteria.** A `direct/web` order pays through the web shop and `direct/android` through the
-android shop, each verified with its own `Password2`, both crediting one `direct` wallet exactly
-once; the E7 report breaks payments down by channel; the split stays contour-safe (the legacy shop
-still works until the cabinet cutover). B4 (fiscalization) verified when the owner's ИП/ОФД/СНО are
-live.
-
-**Notes/risks.** Edge routes fall through if not in the Caddyfile `@gateway` matcher — add a CI
-probe (field note). The prod rolling deploy skips caddy on config-only changes — force-recreate on a
-Caddyfile change. Money-live: expand-contract only, image rollback DB-safe. Confirm the gateway
-emits `direct/android` for the native build before relying on subtype routing.
-
----
-
-## E11 — Payment availability kill switch + per-account override
-
-**Status:** DONE · **Release 2** · depends on: E5 (intake/order), E7 (admin console) · mechanics:
-PAYMENTS §9; decisions D45, D46.
-
-**Delivered.** An operator disables purchases live from `/_gm` — a whole rail/channel or one account
-— and the user sees a localized reason on the next purchase attempt. Motivation (owner): real apps
-show broken payments with no explanation; this gives ops a live switch + a clear user message.
-
-- **Rail kill switch** — `payments.rail_status` (per rail `direct:web` / `direct:android` / `vk` /
-  `telegram`): `enabled` + a per-language message, edited on the catalog page. **Fail-open** (no row
-  ⇒ enabled, so payments are never accidentally killed). The intake gate — `CanPurchase` in
-  `handleWalletOrder`, before the order — returns `payment_unavailable` + the localized message;
-  orthogonal to the security gates.
-- **Per-account override** — `payments.account_payment_override` (a row only for non-default; default
-  = no row, cleared by delete): allow / deny / default, edited on the user card. `allow` bypasses
-  **only** the ops rail switch, never the security gates (D46).
-- **Wire** — the message rides an additive `ExecuteResponse.message` (envelope layer,
-  frozen-contract-safe; the gateway forwards a backend domain-error message via `DomainMessage`); the
-  client reads it into `GatewayError.message` and shows it on a `payment_unavailable` buy attempt.
-- **Tests** — the pure gate `PurchaseGate` (unit, TDD); the store + gate + override end-to-end
-  (integration, migration `00016`); the client (svelte-check / vitest). **Docs** — PAYMENTS (+`_ru`),
-  decisions D45 / D46.
-
-**Contour-safe:** additive migration (two new tables, no wipe); the wire add is additive; fail-open,
-so nothing is disabled until an operator acts.
-
----
-
 ## Verification & CI (all stages)
 
 - Per-stage tests at the layers above; **compliance-gate regression is mandatory** (a

assets/icons/README.md

@@ -1,18 +1,41 @@
-# Icons
+# Erudit — site icons + Open Graph card
 
-The whole shipped icon set is sliced from **one master** — see
+The favicon set and the `og:image` link-preview card for the public landing
-[`brand/`](brand/) for the reference generator, the pinned font and the committed
+(`ui/landing.html`) and the SPA shell (`ui/index.html`). Same design language as the
-outputs, and [`../../docs/ICON_BRANDBOOK.md`](../../docs/ICON_BRANDBOOK.md) for how the
+[VK loading-screen logo](../vk/README.md): the wooden Erudit «Э» tile (score `8`),
-mark is constructed. The per-platform target map (which file goes where) is in
+with the wordmark on the app's dark board green (`ui/src/app.css` tokens).
-[`../../docs/ICONS.md`](../../docs/ICONS.md).
+
+| Output (committed to `ui/public/`) | Purpose |
+|------|---------|
+| `favicon.svg` | Vector favicon, transparent; tile + «Э» only (the score is illegible below ~32 px). |
+| `favicon.ico` | 32×32 PNG-in-ICO fallback (also answers the browsers' blind `/favicon.ico` probe). |
+| `apple-touch-icon.png` | 180×180 opaque full-bleed tile; iOS masks its own corners. |
+| `og-image.png` | 1200×630 card: tile + «Эрудит / Скрэббл — игра в слова». Referenced absolutely as `https://erudit-game.ru/og-image.png`. |
+
+## How it works
+
+`build/extract.js` extracts the needed glyph outlines (tile glyphs + every wordmark
+character) from LiberationSans (Arial-metric, the game's font stack) with their
+advance widths into `build/glyphs.json` (committed). `build/generate.js` composes
+plain SVG from those outlines — no font is needed at generation time — writes
+`favicon.svg` and rasterises the PNG/ICO outputs by screenshotting the SVGs with the
+`ui` package's Playwright chromium (`@playwright/test`); the `.ico` container is
+assembled in-script (a single PNG entry). Raster bytes therefore depend on the
+installed chromium version; the SVG sources are deterministic.
+
+## Regenerate
+
+Requirements: Node ≥ 18, `ui` installed (`pnpm install`, provides Playwright).
+`extract.js` additionally needs `opentype.js` (`npm i opentype.js`); **`generate.js`
+needs no extra packages**.
 
 ```sh
-cd brand
+cd assets/icons
-npm i opentype.js
-node build-set.mjs          # web (ui/public) + Capacitor layers (ui/assets) + vk/ tg/ store/
-node build-android-res.mjs  # Android launcher resources (all densities + monochrome)
-```
 
-> The earlier `build/` pipeline (LiberationSans glyph outlines → favicon/apple-touch/OG)
+# 1. (optional) re-extract the glyphs — only if the font or the wordmark changes:
-> was replaced by `brand/` when the icon was rebranded onto the Spectral «Э» master.
+#    default font: /usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf
-> The separate VK loading-screen animation lives in [`../vk/`](../vk/) and is unrelated.
+node build/extract.js [/path/to/font.ttf]      # -> build/glyphs.json
+
+# 2. regenerate everything in ui/public/:
+node build/generate.js
+```

assets/icons/brand/.gitignore

@@ -1,2 +0,0 @@
-node_modules/
-package-lock.json

assets/icons/brand/README.md

@@ -1,32 +0,0 @@
-# Erudit icon — brand master
-
-The reference construction of the Erudit app icon. The authoritative, human-readable
-spec lives in [`docs/ICON_BRANDBOOK.md`](../../../docs/ICON_BRANDBOOK.md); this folder
-holds the machine reproduction of exactly what that document describes.
-
-| File | What |
-|------|------|
-| `build-icon.mjs` | reference generator — every dimension is a fraction of the side, matching the brand book |
-| `render-png.mjs` | rasterises an icon SVG to PNG via the `ui` package's Playwright chromium |
-| `Spectral-Bold.ttf` | the «Э» typeface (SIL OFL, `Spectral-OFL.txt`) — pinned so the letter never drifts |
-| `icon-light.svg` / `.png` | the light master (1024) |
-| `icon-dark.svg` / `.png` | the dark master (1024) |
-| `icon-construction.svg` / `.png` | the percent-annotated construction scheme (figure in the brand book) |
-
-## Regenerate
-
-```sh
-cd assets/icons/brand
-npm i opentype.js                       # the only extra dep; render uses ui's chromium
-
-node build-icon.mjs --variant light  > icon-light.svg
-node build-icon.mjs --variant dark   > icon-dark.svg
-node build-icon.mjs --variant light --scheme > icon-construction.svg
-
-node render-png.mjs icon-light.svg  icon-light.png  1024
-node render-png.mjs icon-dark.svg   icon-dark.png   1024
-node render-png.mjs icon-construction.svg icon-construction.png 2048
-```
-
-The SVGs are resolution-free; render at any size. Downstream slicing (favicon / PWA /
-iOS / Android) is a separate step — see [`docs/ICONS.md`](../../../docs/ICONS.md).

assets/icons/brand/Spectral-OFL.txt

@@ -1,93 +0,0 @@
-Copyright 2017 The Spectral Project Authors (https://github.com/productiontype/Spectral)
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-https://openfontlicense.org
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.

assets/icons/brand/build-android-res.mjs

@@ -1,53 +0,0 @@
-'use strict';
-// Generate the Android launcher resources from the committed layers, at every
-// density, with NO inset (our layers already fill the 108 dp canvas) and a
-// monochrome (themed) layer. Run build-set.mjs first (it writes the layer PNGs).
-//
-//   npm i opentype.js  # (only build-icon/build-set need it; this reads PNGs)
-//   node build-set.mjs && node build-android-res.mjs
-//
-// Writes ui/android/app/src/main/res/mipmap-*/ic_launcher{,_round,_foreground,
-// _background,_monochrome}.png. The two mipmap-anydpi-v26/*.xml are committed by hand.
-import { readFileSync, writeFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const DIR = dirname(fileURLToPath(import.meta.url));
-const ROOT = join(DIR, '..', '..', '..');
-const RES = join(ROOT, 'ui', 'android', 'app', 'src', 'main', 'res');
-const uri = p => 'data:image/png;base64,' + readFileSync(p).toString('base64');
-const BG = uri(join(ROOT, 'ui', 'assets', 'icon-background.png'));
-const FG = uri(join(ROOT, 'ui', 'assets', 'icon-foreground.png'));
-const MONO = uri(join(DIR, 'android-monochrome.png'));
-// The full-bleed master (square tile + master mark) — the legacy SQUARE launcher (API < 26)
-// uses it so old Android shows a large mark rather than the safe-zone foreground shrunk into
-// the middle. The round legacy icon keeps the safe-zone composite (a round mask would clip
-// the master's corner ✻).
-const MASTER = uri(join(ROOT, 'ui', 'assets', 'icon.png'));
-
-// density: [adaptive-layer px (108 dp), legacy launcher px (48 dp)]
-const D = { ldpi: [81, 36], mdpi: [108, 48], hdpi: [162, 72], xhdpi: [216, 96], xxhdpi: [324, 144], xxxhdpi: [432, 192] };
-
-const pw = await import(join(ROOT, 'ui', 'node_modules', '@playwright', 'test', 'index.js'));
-const { chromium } = pw.default ?? pw;
-const browser = await chromium.launch();
-const page = await browser.newPage({ deviceScaleFactor: 1 });
-const im = (u, s) => `<img src="${u}" width="${s}" height="${s}" style="display:block">`;
-async function shot(html, s, transparent) {
-  await page.setViewportSize({ width: s, height: s });
-  await page.setContent(`<!doctype html><meta charset=utf8><style>*{margin:0;padding:0}#r{width:${s}px;height:${s}px}</style><div id=r>${html}</div>`, { waitUntil: 'networkidle' });
-  return page.locator('#r').screenshot({ omitBackground: !!transparent });
-}
-for (const [d, [fg, lg]] of Object.entries(D)) {
-  const dir = join(RES, `mipmap-${d}`);
-  writeFileSync(join(dir, 'ic_launcher_background.png'), await shot(im(BG, fg), fg, false));
-  writeFileSync(join(dir, 'ic_launcher_foreground.png'), await shot(im(FG, fg), fg, true));
-  writeFileSync(join(dir, 'ic_launcher_monochrome.png'), await shot(im(MONO, fg), fg, true));
-  // Square launcher: the full-bleed master (large mark). Round launcher: the safe-zone
-  // composite, circle-clipped (the master's corner ✻ would be clipped by the round mask).
-  writeFileSync(join(dir, 'ic_launcher.png'), await shot(im(MASTER, lg), lg, false));
-  const round = `<div style="width:${lg}px;height:${lg}px;border-radius:50%;overflow:hidden;position:relative">${im(BG, lg)}<div style="position:absolute;inset:0">${im(FG, lg)}</div></div>`;
-  writeFileSync(join(dir, 'ic_launcher_round.png'), await shot(round, lg, true));
-  console.log('mipmap-' + d, 'ok');
-}
-await browser.close();

assets/icons/brand/build-icon.mjs

@@ -1,163 +0,0 @@
-'use strict';
-// Erudit app-icon — the reference generator. Every dimension below is a FRACTION
-// of the icon side, so this file reads the same as docs/ICON_BRANDBOOK.md and the
-// icon reproduces at any resolution. Emits one variant/layer's SVG to stdout.
-//
-//   node build-icon.mjs --variant light|dark [--layer full|background|foreground] [--scheme] > icon.svg
-//
-// Layers (for Android adaptive icons):
-//   full        the standalone master (rounded tile + mark) — iOS / PWA / favicon
-//   background  wood + grain + light/shadow, full-bleed square (the OS applies the mask)
-//   foreground  only «Э» + ✻, transparent, re-placed for the round mask (see FG_* below)
-//
-// Deps: opentype.js (npm i opentype.js). Font: ./Spectral-Bold.ttf (OFL, bundled).
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import opentype from 'opentype.js';
-
-const DIR = dirname(fileURLToPath(import.meta.url));
-const args = process.argv.slice(2);
-const has = f => args.includes('--' + f);
-const val = (f, d) => { const i = args.indexOf('--' + f); return i >= 0 ? args[i + 1] : d; };
-
-// ---- the design, in fractions of the side ----
-const S = 1024;                       // reference side (the icon is resolution-free)
-const RADIUS   = 0.17;                // tile corner radius (full master)
-const STAR_BULB = 0.22;               // spoke-end (and hub) radius, as fraction of star radius
-const STAR_SPOKES = 6;
-const GRAIN_COLS = 6, GRAIN_W = 1 / 32, GRAIN_SHIFT = 1 / 16, GRAIN_TILT = 4;
-const SHEEN = 0.15;                   // white, transparent bottom-left -> this alpha top-right
-const SHADE = 0.15;                   // black, this alpha bottom-left -> transparent top-right
-
-// The mark, placed for the standalone master (bottom-right biased, full-bleed):
-const MASTER = { lh: 0.6055, lc: [0.4814, 0.4922], sd: 0.1729, sc: [0.7881, 0.7881] };
-// The mark, placed for the Android foreground layer (centred-ish inside the 61% safe
-// zone, nudged right 8% / down 3% for optical balance under the round mask; smaller ✻).
-// Every value is the earlier placement scaled 0.75 about the icon centre (0.5, 0.5): the
-// whole mark is 25% smaller, its «Э»↔✻ arrangement unchanged, so the ✻ that used to graze
-// the round mask now sits well inside the safe zone. Round-mask launchers (adaptive + the
-// legacy round icon) get more breathing room; the full-bleed master is untouched.
-const FOREGROUND = { lh: 0.4043, lc: [0.5176, 0.4963], sd: 0.0989, sc: [0.6970, 0.6700] };
-
-const PALETTE = {
-  light: { wood: '#e6b053', ink: '#5a3a12', grain: '#d8a54e' },
-  dark:  { wood: '#4a3316', ink: '#f2d9a0', grain: '#432e14' },
-};
-
-// Layers:
-//   full        rounded tile + master mark        (favicon.svg — browser rounds nothing)
-//   flat        square tile + master mark          (apple-touch, PWA "any" — OS rounds)
-//   background  square tile, no mark               (Android adaptive background)
-//   foreground  mark only, transparent             (Android adaptive foreground)
-//   maskable    square tile + foreground mark       (PWA maskable — safe-zone aware)
-//   monochrome  foreground mark only, flat colour  (Android 13+ themed layer)
-const LAYERS = ['full', 'flat', 'background', 'foreground', 'maskable', 'monochrome'];
-const variant = val('variant', 'light');
-const layer = val('layer', 'full');
-const P = PALETTE[variant];
-if (!P) { console.error(`unknown --variant ${variant} (light|dark)`); process.exit(1); }
-if (!LAYERS.includes(layer)) { console.error(`unknown --layer ${layer} (${LAYERS.join('|')})`); process.exit(1); }
-
-const usesForegroundPlacement = ['foreground', 'maskable', 'monochrome'].includes(layer);
-const drawBg = ['full', 'flat', 'background', 'maskable'].includes(layer);
-const drawMark = layer !== 'background';
-const MARK = usesForegroundPlacement ? FOREGROUND : MASTER;
-const inkColour = layer === 'monochrome' ? val('mono', '#ffffff') : P.ink;
-const RX = layer === 'full' ? RADIUS * S : 0;   // only the standalone master keeps rounded corners
-const font = opentype.parse(readFileSync(join(DIR, 'Spectral-Bold.ttf')).buffer);
-
-// «Э» outline scaled so its ink bounding box is MARK.lh of the side, box centred on MARK.lc.
-function letterSvg() {
-  const g = font.charToGlyph('Э');
-  const h0 = (() => { const b = g.getPath(0, 0, 1000).getBoundingBox(); return b.y2 - b.y1; })();
-  const scale = (MARK.lh * S) / h0;
-  const p = g.getPath(0, 0, 1000 * scale);
-  const bb = p.getBoundingBox();
-  const w = bb.x2 - bb.x1, h = bb.y2 - bb.y1;
-  const tx = MARK.lc[0] * S - (bb.x1 + w / 2);
-  const ty = MARK.lc[1] * S - (bb.y1 + h / 2);
-  return { svg: `<path transform="translate(${tx.toFixed(2)} ${ty.toFixed(2)})" d="${p.toPathData(2)}" fill="${inkColour}"/>`,
-           box: { x: bb.x1 + tx, y: bb.y1 + ty, w, h } };
-}
-
-// Teardrop-spoked asterisk ✻: each spoke tapers to a point at the centre and ends
-// in a round bulb; a central disc equal to the bulb fuses them.
-function starPath() {
-  const cx = MARK.sc[0] * S, cy = MARK.sc[1] * S, Rout = MARK.sd * S / 2;
-  const rb = Rout * STAR_BULB, R = Rout - rb;
-  const L = Math.sqrt(R * R - rb * rb), theta = Math.asin(rb / R);
-  const rot = (v, t) => [v[0] * Math.cos(t) - v[1] * Math.sin(t), v[0] * Math.sin(t) + v[1] * Math.cos(t)];
-  let d = '';
-  for (let k = 0; k < STAR_SPOKES; k++) {
-    const a = -Math.PI / 2 + k * 2 * Math.PI / STAR_SPOKES;
-    const u = [Math.cos(a), Math.sin(a)];
-    const d1 = rot(u, theta), d2 = rot(u, -theta);
-    const T1 = [cx + L * d1[0], cy + L * d1[1]], T2 = [cx + L * d2[0], cy + L * d2[1]];
-    d += `M${cx.toFixed(2)} ${cy.toFixed(2)} L${T1[0].toFixed(2)} ${T1[1].toFixed(2)} A${rb.toFixed(2)} ${rb.toFixed(2)} 0 1 0 ${T2[0].toFixed(2)} ${T2[1].toFixed(2)} Z `;
-  }
-  d += `M${cx} ${cy} m${-rb} 0 a${rb} ${rb} 0 1 0 ${2 * rb} 0 a${rb} ${rb} 0 1 0 ${-2 * rb} 0 Z`;
-  return `<path d="${d}" fill="${inkColour}"/>`;
-}
-
-function grain() {
-  const colW = S / GRAIN_COLS, sw = GRAIN_W * S, shift = GRAIN_SHIFT * S;
-  const yTop = -0.2 * S, yBot = 1.2 * S, cy = S / 2;
-  let s = '';
-  for (let i = 1; i <= GRAIN_COLS; i++) {
-    const xr = i * colW - shift, x = xr - sw, cx = xr - sw / 2;
-    s += `<rect x="${x.toFixed(2)}" y="${yTop.toFixed(2)}" width="${sw.toFixed(2)}" height="${(yBot - yTop).toFixed(2)}" fill="${P.grain}" transform="rotate(${GRAIN_TILT} ${cx.toFixed(2)} ${cy.toFixed(2)})"/>`;
-  }
-  return `<g clip-path="url(#tile)">${s}</g>`;
-}
-
-let body = '';
-const L = letterSvg();
-if (drawBg) {                           // tile + grain + light/shadow (the background)
-  body += `<rect width="${S}" height="${S}" rx="${RX}" fill="${P.wood}"/>`
-    + `<defs><clipPath id="tile"><rect width="${S}" height="${S}" rx="${RX}"/></clipPath>`
-    +   `<linearGradient id="sheen" gradientUnits="userSpaceOnUse" x1="0" y1="${S}" x2="${S}" y2="0"><stop offset="0" stop-color="#fff" stop-opacity="0"/><stop offset="1" stop-color="#fff" stop-opacity="${SHEEN}"/></linearGradient>`
-    +   `<linearGradient id="shade" gradientUnits="userSpaceOnUse" x1="0" y1="${S}" x2="${S}" y2="0"><stop offset="0" stop-color="#000" stop-opacity="${SHADE}"/><stop offset="1" stop-color="#000" stop-opacity="0"/></linearGradient>`
-    + `</defs>`
-    + grain()
-    + `<rect width="${S}" height="${S}" fill="url(#sheen)" clip-path="url(#tile)"/>`
-    + `<rect width="${S}" height="${S}" fill="url(#shade)" clip-path="url(#tile)"/>`;
-}
-if (drawMark) body += L.svg + starPath();   // the mark
-if (has('scheme')) body += scheme(L);
-
-process.stdout.write(`<svg xmlns="http://www.w3.org/2000/svg" width="${S}" height="${S}" viewBox="0 0 ${S} ${S}">${body}</svg>\n`);
-
-// Percent-based construction overlay for the brand book (full master only).
-function scheme(L) {
-  const pc = n => (100 * n / S).toFixed(1) + '%';
-  const GC = '#0f172a', BX = '#d81b60', AC = '#0d9488';
-  const halo = 'paint-order="stroke" stroke="#fff" stroke-width="4"';
-  const cx = MARK.sc[0] * S, cy = MARK.sc[1] * S, sd = MARK.sd * S;
-  let g = `<g font-family="'Helvetica Neue',Arial,sans-serif">`;
-  for (let f = 1; f <= 3; f++) {
-    const p = f * S / 4;
-    g += `<line x1="${p}" y1="0" x2="${p}" y2="${S}" stroke="${GC}" stroke-opacity="0.18" stroke-width="1.2"/>`;
-    g += `<line x1="0" y1="${p}" x2="${S}" y2="${p}" stroke="${GC}" stroke-opacity="0.18" stroke-width="1.2"/>`;
-    g += `<text x="${p + 4}" y="20" font-size="17" font-weight="700" fill="${GC}" ${halo}>${f * 25}%</text>`;
-    g += `<text x="4" y="${p - 4}" font-size="17" font-weight="700" fill="${GC}" ${halo}>${f * 25}%</text>`;
-  }
-  g += `<line x1="${0.14 * S}" y1="${0.86 * S}" x2="${0.86 * S}" y2="${0.14 * S}" stroke="${AC}" stroke-width="3" stroke-dasharray="3 8" stroke-linecap="round"/>`;
-  g += `<circle cx="${0.86 * S}" cy="${0.14 * S}" r="6" fill="${AC}"/><circle cx="${0.14 * S}" cy="${0.86 * S}" r="6" fill="${AC}"/>`;
-  g += `<text x="${0.86 * S - 6}" y="${0.14 * S - 12}" text-anchor="end" font-size="18" font-weight="700" fill="${AC}" ${halo}>light: white 0%→15%</text>`;
-  g += `<text x="${0.14 * S + 10}" y="${0.86 * S + 26}" font-size="18" font-weight="700" fill="${AC}" ${halo}>shadow: black 15%→0%</text>`;
-  const { x, y, w, h } = L.box;
-  g += `<rect x="${x.toFixed(1)}" y="${y.toFixed(1)}" width="${w.toFixed(1)}" height="${h.toFixed(1)}" fill="none" stroke="${BX}" stroke-width="2.5"/>`;
-  g += `<line x1="${MARK.lc[0] * S}" y1="${MARK.lc[1] * S - 16}" x2="${MARK.lc[0] * S}" y2="${MARK.lc[1] * S + 16}" stroke="${BX}" stroke-width="2.5"/><line x1="${MARK.lc[0] * S - 16}" y1="${MARK.lc[1] * S}" x2="${MARK.lc[0] * S + 16}" y2="${MARK.lc[1] * S}" stroke="${BX}" stroke-width="2.5"/>`;
-  g += `<text x="${x.toFixed(1)}" y="${(y - 10).toFixed(1)}" font-size="19" font-weight="700" fill="${BX}" ${halo}>«Э» Spectral Bold · box H ${pc(h)} · W ${pc(w)}</text>`;
-  g += `<text x="${x.toFixed(1)}" y="${(y + h + 24).toFixed(1)}" font-size="18" font-weight="700" fill="${BX}" ${halo}>box center ${pc(MARK.lc[0] * S)} / ${pc(MARK.lc[1] * S)}</text>`;
-  g += `<rect x="${cx - sd / 2}" y="${cy - sd / 2}" width="${sd}" height="${sd}" fill="none" stroke="${BX}" stroke-width="2.5"/>`;
-  g += `<line x1="${cx}" y1="${cy - 14}" x2="${cx}" y2="${cy + 14}" stroke="${BX}" stroke-width="2.5"/><line x1="${cx - 14}" y1="${cy}" x2="${cx + 14}" y2="${cy}" stroke="${BX}" stroke-width="2.5"/>`;
-  g += `<text x="${(cx + sd / 2).toFixed(1)}" y="${(cy - sd / 2 - 10).toFixed(1)}" text-anchor="end" font-size="18" font-weight="700" fill="${BX}" ${halo}>✻ Ø ${pc(sd)} · center ${pc(cx)} / ${pc(cy)}</text>`;
-  g += `<text x="${RX + 14}" y="${RX - 6}" font-size="17" font-weight="700" fill="${GC}" ${halo}>corner r = 17%</text>`;
-  g += `<path d="M4 ${RX} A ${RX} ${RX} 0 0 1 ${RX} 4" fill="none" stroke="${GC}" stroke-width="2" stroke-dasharray="5 5"/>`;
-  g += `<rect x="${0.03 * S}" y="${S - 96}" width="${0.94 * S}" height="74" rx="12" fill="#0f172a" fill-opacity="0.82"/>`;
-  g += `<text x="${0.055 * S}" y="${S - 64}" font-size="18" font-weight="600" fill="#fff">Wood grain: 6 equal columns; a vertical stripe on each column's right edge,</text>`;
-  g += `<text x="${0.055 * S}" y="${S - 40}" font-size="18" font-weight="600" fill="#fff">width 1/32 of side; the whole set shifted left 1/16; every stripe tilted 4°.</text>`;
-  return g + `</g>`;
-}

assets/icons/brand/build-set.mjs

@@ -1,105 +0,0 @@
-'use strict';
-// Slice the whole shipped icon set from the brand master (build-icon.mjs). Renders
-// with the ui package's Playwright chromium. See docs/ICONS.md for the target map.
-//
-//   npm i opentype.js && node build-set.mjs
-//
-// Writes: ui/public/* (web), ui/assets/* (Capacitor layers), ./vk/* and ./store/*
-// (manual-upload art). Wiring (manifest, html, Android res) is done separately.
-import { execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const DIR = dirname(fileURLToPath(import.meta.url));
-const UI = join(DIR, '..', '..', '..', 'ui');
-const PUB = join(UI, 'public'), ASSETS = join(UI, 'assets');
-const VK = join(DIR, 'vk'), STORE = join(DIR, 'store'), TG = join(DIR, 'tg');
-[VK, STORE, TG].forEach(d => mkdirSync(d, { recursive: true }));
-
-// one SVG string for a variant+layer from the reference generator
-const svgFor = (variant, layer) =>
-  execFileSync('node', [join(DIR, 'build-icon.mjs'), '--variant', variant, '--layer', layer], { encoding: 'utf8' });
-
-const pw = await import(join(UI, 'node_modules', '@playwright', 'test', 'index.js'));
-const { chromium } = pw.default ?? pw;
-const browser = await chromium.launch();
-const page = await browser.newPage();
-
-async function pngFromSvg(svg, size, transparent) {
-  await page.setViewportSize({ width: size, height: size });
-  await page.setContent(`<!doctype html><meta charset=utf8><style>*{margin:0;padding:0}svg{display:block;width:${size}px;height:${size}px}</style>${svg}`, { waitUntil: 'networkidle' });
-  return page.locator('svg').screenshot({ omitBackground: !!transparent });
-}
-async function shootHtml(html, w, h) {
-  await page.setViewportSize({ width: w, height: h });
-  await page.setContent(html, { waitUntil: 'networkidle' });
-  return page.screenshot();
-}
-function icoFromPNG(png, sizePx) {
-  const h = Buffer.alloc(22);
-  h.writeUInt16LE(0, 0); h.writeUInt16LE(1, 2); h.writeUInt16LE(1, 4);
-  h.writeUInt8(sizePx, 6); h.writeUInt8(sizePx, 7);
-  h.writeUInt16LE(1, 10); h.writeUInt16LE(32, 12);
-  h.writeUInt32LE(png.length, 14); h.writeUInt32LE(22, 18);
-  return Buffer.concat([h, png]);
-}
-const write = (p, buf) => { writeFileSync(p, buf); console.log('wrote', p.replace(join(DIR, '..', '..', '..'), '.'), buf.length, 'b'); };
-
-// ---- pre-render the SVG sources we need ----
-const S = {
-  fullLight: svgFor('light', 'full'), fullDark: svgFor('dark', 'full'),
-  flatLight: svgFor('light', 'flat'), flatDark: svgFor('dark', 'flat'),
-  maskLight: svgFor('light', 'maskable'), maskDark: svgFor('dark', 'maskable'),
-  bgLight: svgFor('light', 'background'), fgLight: svgFor('light', 'foreground'),
-  monoLight: svgFor('light', 'monochrome'),
-};
-
-// ---- favicon.svg: light + dark in one file, toggled by prefers-color-scheme ----
-const inner = svg => svg.replace(/^<svg[^>]*>/, '').replace(/<\/svg>\s*$/, '');
-const faviconSvg =
-  `<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024">`
-  + `<style>.d{display:none}@media(prefers-color-scheme:dark){.l{display:none}.d{display:inline}}</style>`
-  + `<g class="l">${inner(S.fullLight)}</g><g class="d">${inner(S.fullDark)}</g></svg>\n`;
-write(join(PUB, 'favicon.svg'), Buffer.from(faviconSvg));
-
-// ---- web rasters ----
-write(join(PUB, 'favicon.ico'), icoFromPNG(await pngFromSvg(S.flatLight, 32, false), 32));
-write(join(PUB, 'apple-touch-icon.png'), await pngFromSvg(S.flatLight, 180, false));
-write(join(PUB, 'icon-192.png'), await pngFromSvg(S.flatLight, 192, false));
-write(join(PUB, 'icon-512.png'), await pngFromSvg(S.flatLight, 512, false));
-write(join(PUB, 'icon-192-dark.png'), await pngFromSvg(S.flatDark, 192, false));
-write(join(PUB, 'icon-512-dark.png'), await pngFromSvg(S.flatDark, 512, false));
-write(join(PUB, 'icon-maskable-512.png'), await pngFromSvg(S.maskLight, 512, false));
-write(join(PUB, 'icon-maskable-512-dark.png'), await pngFromSvg(S.maskDark, 512, false));
-
-// ---- Capacitor layers (ui/assets) ----
-write(join(ASSETS, 'icon.png'), await pngFromSvg(S.flatLight, 1024, false));          // legacy single
-write(join(ASSETS, 'icon-foreground.png'), await pngFromSvg(S.fgLight, 1024, true));   // adaptive fg
-write(join(ASSETS, 'icon-background.png'), await pngFromSvg(S.bgLight, 1024, false));  // adaptive bg
-write(join(DIR, 'android-monochrome.png'), await pngFromSvg(S.monoLight, 1024, true)); // themed layer (wired manually)
-
-// ---- VK (no rounding — flat light) ----
-for (const px of [576, 278, 150, 32]) write(join(VK, `vk-${px}.png`), await pngFromSvg(S.flatLight, px, false));
-
-// ---- Telegram bot: square, no rounding (TG crops the avatar to a circle) ----
-write(join(TG, 'tg-512.png'), await pngFromSvg(S.flatLight, 512, false));   // bot avatar + Mini App icon
-
-// ---- store art ----
-write(join(STORE, 'rustore-512.png'), await pngFromSvg(S.flatLight, 512, false));
-
-// ---- wordmark banner (board-green bg + master tile + «Эрудит» / Игра в слова) ----
-const b64 = readFileSync(join(DIR, 'Spectral-Bold.ttf')).toString('base64');
-const banner = (w, h, tile, t1, t2, gap, pad) => `<!doctype html><meta charset=utf8><style>
-@font-face{font-family:Spectral;src:url(data:font/ttf;base64,${b64});font-weight:700}
-*{margin:0;padding:0;box-sizing:border-box}
-body{width:${w}px;height:${h}px;background:#2a3330;display:flex;align-items:center;gap:${gap}px;padding:0 ${pad}px;font-family:Spectral}
-.tile{width:${tile}px;height:${tile}px;flex:none}.tile svg{width:${tile}px;height:${tile}px;display:block}
-.wm{color:#e7ece8;text-align:center}.t1{font-weight:700;font-size:${t1}px;line-height:1.02;letter-spacing:-2px}
-.t2{font-weight:700;font-size:${t2}px;line-height:1.1;color:#cdd6cf;margin-top:6px}
-</style><div class=tile>${S.fullLight}</div><div class=wm><div class=t1>«Эрудит»</div><div class=t2>Игра в слова</div></div>`;
-write(join(PUB, 'og-image.png'), await shootHtml(banner(1200, 630, 300, 150, 74, 64, 96), 1200, 630));
-write(join(TG, 'tg-demo-640x360.png'), await shootHtml(banner(640, 360, 150, 72, 38, 30, 44), 640, 360));
-
-await browser.close();
-console.log('done');

assets/icons/brand/icon-dark-android-background.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024"><rect width="1024" height="1024" rx="0" fill="#4a3316"/><defs><clipPath id="tile"><rect width="1024" height="1024" rx="0"/></clipPath><linearGradient id="sheen" gradientUnits="userSpaceOnUse" x1="0" y1="1024" x2="1024" y2="0"><stop offset="0" stop-color="#fff" stop-opacity="0"/><stop offset="1" stop-color="#fff" stop-opacity="0.15"/></linearGradient><linearGradient id="shade" gradientUnits="userSpaceOnUse" x1="0" y1="1024" x2="1024" y2="0"><stop offset="0" stop-color="#000" stop-opacity="0.15"/><stop offset="1" stop-color="#000" stop-opacity="0"/></linearGradient></defs><g clip-path="url(#tile)"><rect x="74.67" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 90.67 512.00)"/><rect x="245.33" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 261.33 512.00)"/><rect x="416.00" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 432.00 512.00)"/><rect x="586.67" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 602.67 512.00)"/><rect x="757.33" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 773.33 512.00)"/><rect x="928.00" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 944.00 512.00)"/></g><rect width="1024" height="1024" fill="url(#sheen)" clip-path="url(#tile)"/><rect width="1024" height="1024" fill="url(#shade)" clip-path="url(#tile)"/></svg>

assets/icons/brand/icon-dark-android-foreground.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024"><path transform="translate(237.62 774.88)" d="M250.04-34.91Q326.35-34.91 368.57-91.33Q410.78-147.75 410.78-243.55Q410.78-249.23 410.78-254.91L254.10-254.91L208.64-185.91L195.65-185.91L195.65-368.57L208.64-368.57L254.10-299.56L407.53-299.56Q396.98-392.92 351.52-447.72Q306.06-502.52 241.11-502.52Q217.57-502.52 198.90-498.46Q180.22-494.40 162.36-482.22L83.62-354.77L69-354.77L77.93-505.76Q112.84-522.81 154.25-533.37Q195.65-543.92 259.78-543.92Q319.86-543.92 371.41-523.22Q422.96-502.52 460.71-465.58Q498.46-428.64 519.57-378.31Q540.67-327.98 540.67-267.90Q540.67-188.34 504.55-125.83Q468.42-63.32 405.10-27.60Q341.78 8.12 259.78 8.12Q200.52 8.12 150.59-3.25Q100.67-14.61 67.38-34.10L56.02-171.29L69.82-171.29L142.88-63.32Q165.61-50.33 191.59-42.62Q217.57-34.91 250.04-34.91" fill="#f2d9a0"/><path d="M781.00 744.04 L795.25 695.59 A14.85 14.85 0 1 0 766.76 695.59 Z M781.00 744.04 L830.08 732.15 A14.85 14.85 0 1 0 815.84 707.48 Z M781.00 744.04 L815.84 780.60 A14.85 14.85 0 1 0 830.08 755.93 Z M781.00 744.04 L766.76 792.49 A14.85 14.85 0 1 0 795.25 792.49 Z M781.00 744.04 L731.93 755.93 A14.85 14.85 0 1 0 746.17 780.60 Z M781.00 744.04 L746.17 707.48 A14.85 14.85 0 1 0 731.93 732.15 Z M781.0048 744.0384 m-14.845952 0 a14.845952 14.845952 0 1 0 29.691904 0 a14.845952 14.845952 0 1 0 -29.691904 0 Z" fill="#f2d9a0"/></svg>

assets/icons/brand/icon-dark.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024"><rect width="1024" height="1024" rx="174.08" fill="#4a3316"/><defs><clipPath id="tile"><rect width="1024" height="1024" rx="174.08"/></clipPath><linearGradient id="sheen" gradientUnits="userSpaceOnUse" x1="0" y1="1024" x2="1024" y2="0"><stop offset="0" stop-color="#fff" stop-opacity="0"/><stop offset="1" stop-color="#fff" stop-opacity="0.15"/></linearGradient><linearGradient id="shade" gradientUnits="userSpaceOnUse" x1="0" y1="1024" x2="1024" y2="0"><stop offset="0" stop-color="#000" stop-opacity="0.15"/><stop offset="1" stop-color="#000" stop-opacity="0"/></linearGradient></defs><g clip-path="url(#tile)"><rect x="74.67" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 90.67 512.00)"/><rect x="245.33" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 261.33 512.00)"/><rect x="416.00" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 432.00 512.00)"/><rect x="586.67" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 602.67 512.00)"/><rect x="757.33" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 773.33 512.00)"/><rect x="928.00" y="-204.80" width="32.00" height="1433.60" fill="#432e14" transform="rotate(4 944.00 512.00)"/></g><rect width="1024" height="1024" fill="url(#sheen)" clip-path="url(#tile)"/><rect width="1024" height="1024" fill="url(#shade)" clip-path="url(#tile)"/><path transform="translate(157.86 804.91)" d="M280.84-39.21Q366.55-39.21 413.96-102.58Q461.38-165.95 461.38-273.54Q461.38-279.93 461.38-286.31L285.40-286.31L234.34-208.80L219.75-208.80L219.75-413.96L234.34-413.96L285.40-336.46L457.73-336.46Q445.88-441.32 394.81-502.86Q343.75-564.41 270.81-564.41Q244.37-564.41 223.39-559.85Q202.42-555.29 182.36-541.62L93.92-398.46L77.50-398.46L87.53-568.06Q126.74-587.21 173.24-599.06Q219.75-610.91 291.78-610.91Q359.25-610.91 417.15-587.66Q475.05-564.41 517.45-522.92Q559.85-481.44 583.56-424.90Q607.27-368.37 607.27-300.90Q607.27-211.54 566.69-141.33Q526.12-71.12 454.99-31Q383.87 9.12 291.78 9.12Q225.22 9.12 169.14-3.65Q113.06-16.41 75.68-38.30L62.92-192.39L78.42-192.39L160.48-71.12Q186.01-56.53 215.19-47.87Q244.37-39.21 280.84-39.21" fill="#f2d9a0"/><path d="M807.01 807.01 L825.70 743.46 A19.48 19.48 0 1 0 788.33 743.46 Z M807.01 807.01 L871.40 791.42 A19.48 19.48 0 1 0 852.71 759.05 Z M807.01 807.01 L852.71 854.97 A19.48 19.48 0 1 0 871.40 822.61 Z M807.01 807.01 L788.33 870.57 A19.48 19.48 0 1 0 825.70 870.57 Z M807.01 807.01 L742.63 822.61 A19.48 19.48 0 1 0 761.32 854.97 Z M807.01 807.01 L761.32 759.05 A19.48 19.48 0 1 0 742.63 791.42 Z M807.0144 807.0144 m-19.475456 0 a19.475456 19.475456 0 1 0 38.950912 0 a19.475456 19.475456 0 1 0 -38.950912 0 Z" fill="#f2d9a0"/></svg>

assets/icons/brand/icon-light-android-background.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024"><rect width="1024" height="1024" rx="0" fill="#e6b053"/><defs><clipPath id="tile"><rect width="1024" height="1024" rx="0"/></clipPath><linearGradient id="sheen" gradientUnits="userSpaceOnUse" x1="0" y1="1024" x2="1024" y2="0"><stop offset="0" stop-color="#fff" stop-opacity="0"/><stop offset="1" stop-color="#fff" stop-opacity="0.15"/></linearGradient><linearGradient id="shade" gradientUnits="userSpaceOnUse" x1="0" y1="1024" x2="1024" y2="0"><stop offset="0" stop-color="#000" stop-opacity="0.15"/><stop offset="1" stop-color="#000" stop-opacity="0"/></linearGradient></defs><g clip-path="url(#tile)"><rect x="74.67" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 90.67 512.00)"/><rect x="245.33" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 261.33 512.00)"/><rect x="416.00" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 432.00 512.00)"/><rect x="586.67" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 602.67 512.00)"/><rect x="757.33" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 773.33 512.00)"/><rect x="928.00" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 944.00 512.00)"/></g><rect width="1024" height="1024" fill="url(#sheen)" clip-path="url(#tile)"/><rect width="1024" height="1024" fill="url(#shade)" clip-path="url(#tile)"/></svg>

assets/icons/brand/icon-light-android-foreground.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024"><path transform="translate(237.62 774.88)" d="M250.04-34.91Q326.35-34.91 368.57-91.33Q410.78-147.75 410.78-243.55Q410.78-249.23 410.78-254.91L254.10-254.91L208.64-185.91L195.65-185.91L195.65-368.57L208.64-368.57L254.10-299.56L407.53-299.56Q396.98-392.92 351.52-447.72Q306.06-502.52 241.11-502.52Q217.57-502.52 198.90-498.46Q180.22-494.40 162.36-482.22L83.62-354.77L69-354.77L77.93-505.76Q112.84-522.81 154.25-533.37Q195.65-543.92 259.78-543.92Q319.86-543.92 371.41-523.22Q422.96-502.52 460.71-465.58Q498.46-428.64 519.57-378.31Q540.67-327.98 540.67-267.90Q540.67-188.34 504.55-125.83Q468.42-63.32 405.10-27.60Q341.78 8.12 259.78 8.12Q200.52 8.12 150.59-3.25Q100.67-14.61 67.38-34.10L56.02-171.29L69.82-171.29L142.88-63.32Q165.61-50.33 191.59-42.62Q217.57-34.91 250.04-34.91" fill="#5a3a12"/><path d="M781.00 744.04 L795.25 695.59 A14.85 14.85 0 1 0 766.76 695.59 Z M781.00 744.04 L830.08 732.15 A14.85 14.85 0 1 0 815.84 707.48 Z M781.00 744.04 L815.84 780.60 A14.85 14.85 0 1 0 830.08 755.93 Z M781.00 744.04 L766.76 792.49 A14.85 14.85 0 1 0 795.25 792.49 Z M781.00 744.04 L731.93 755.93 A14.85 14.85 0 1 0 746.17 780.60 Z M781.00 744.04 L746.17 707.48 A14.85 14.85 0 1 0 731.93 732.15 Z M781.0048 744.0384 m-14.845952 0 a14.845952 14.845952 0 1 0 29.691904 0 a14.845952 14.845952 0 1 0 -29.691904 0 Z" fill="#5a3a12"/></svg>

assets/icons/brand/icon-light.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024"><rect width="1024" height="1024" rx="174.08" fill="#e6b053"/><defs><clipPath id="tile"><rect width="1024" height="1024" rx="174.08"/></clipPath><linearGradient id="sheen" gradientUnits="userSpaceOnUse" x1="0" y1="1024" x2="1024" y2="0"><stop offset="0" stop-color="#fff" stop-opacity="0"/><stop offset="1" stop-color="#fff" stop-opacity="0.15"/></linearGradient><linearGradient id="shade" gradientUnits="userSpaceOnUse" x1="0" y1="1024" x2="1024" y2="0"><stop offset="0" stop-color="#000" stop-opacity="0.15"/><stop offset="1" stop-color="#000" stop-opacity="0"/></linearGradient></defs><g clip-path="url(#tile)"><rect x="74.67" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 90.67 512.00)"/><rect x="245.33" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 261.33 512.00)"/><rect x="416.00" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 432.00 512.00)"/><rect x="586.67" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 602.67 512.00)"/><rect x="757.33" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 773.33 512.00)"/><rect x="928.00" y="-204.80" width="32.00" height="1433.60" fill="#d8a54e" transform="rotate(4 944.00 512.00)"/></g><rect width="1024" height="1024" fill="url(#sheen)" clip-path="url(#tile)"/><rect width="1024" height="1024" fill="url(#shade)" clip-path="url(#tile)"/><path transform="translate(157.86 804.91)" d="M280.84-39.21Q366.55-39.21 413.96-102.58Q461.38-165.95 461.38-273.54Q461.38-279.93 461.38-286.31L285.40-286.31L234.34-208.80L219.75-208.80L219.75-413.96L234.34-413.96L285.40-336.46L457.73-336.46Q445.88-441.32 394.81-502.86Q343.75-564.41 270.81-564.41Q244.37-564.41 223.39-559.85Q202.42-555.29 182.36-541.62L93.92-398.46L77.50-398.46L87.53-568.06Q126.74-587.21 173.24-599.06Q219.75-610.91 291.78-610.91Q359.25-610.91 417.15-587.66Q475.05-564.41 517.45-522.92Q559.85-481.44 583.56-424.90Q607.27-368.37 607.27-300.90Q607.27-211.54 566.69-141.33Q526.12-71.12 454.99-31Q383.87 9.12 291.78 9.12Q225.22 9.12 169.14-3.65Q113.06-16.41 75.68-38.30L62.92-192.39L78.42-192.39L160.48-71.12Q186.01-56.53 215.19-47.87Q244.37-39.21 280.84-39.21" fill="#5a3a12"/><path d="M807.01 807.01 L825.70 743.46 A19.48 19.48 0 1 0 788.33 743.46 Z M807.01 807.01 L871.40 791.42 A19.48 19.48 0 1 0 852.71 759.05 Z M807.01 807.01 L852.71 854.97 A19.48 19.48 0 1 0 871.40 822.61 Z M807.01 807.01 L788.33 870.57 A19.48 19.48 0 1 0 825.70 870.57 Z M807.01 807.01 L742.63 822.61 A19.48 19.48 0 1 0 761.32 854.97 Z M807.01 807.01 L761.32 759.05 A19.48 19.48 0 1 0 742.63 791.42 Z M807.0144 807.0144 m-19.475456 0 a19.475456 19.475456 0 1 0 38.950912 0 a19.475456 19.475456 0 1 0 -38.950912 0 Z" fill="#5a3a12"/></svg>

assets/icons/brand/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "erudit-icon-brand",
-  "private": true,
-  "type": "module",
-  "description": "Reference generator for the Erudit app-icon set (see docs/ICON_BRANDBOOK.md).",
-  "scripts": {
-    "build": "node build-set.mjs && node build-android-res.mjs"
-  },
-  "dependencies": {
-    "opentype.js": "^1.3.4"
-  }
-}

assets/icons/brand/render-png.mjs

@@ -1,21 +0,0 @@
-'use strict';
-// Rasterise an icon SVG to PNG at a given size, using the `ui` package's cached
-// Playwright chromium (no extra install). Usage:
-//   node render-png.mjs <in.svg> <out.png> [size=1024]
-import { readFileSync, writeFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const DIR = dirname(fileURLToPath(import.meta.url));
-const pw = await import(join(DIR, '..', '..', '..', 'ui', 'node_modules', '@playwright', 'test', 'index.js'));
-const { chromium } = pw.default ?? pw;
-
-const [, , svgPath, pngPath, size] = process.argv;
-const S = Number(size) || 1024;
-const svg = readFileSync(svgPath, 'utf8');
-const b = await chromium.launch();
-const pg = await b.newPage({ viewport: { width: S, height: S }, deviceScaleFactor: 1 });
-await pg.setContent(`<!doctype html><meta charset=utf8><style>*{margin:0;padding:0}</style>${svg}`, { waitUntil: 'networkidle' });
-writeFileSync(pngPath, await pg.locator('svg').screenshot({ omitBackground: true }));
-await b.close();
-console.log('wrote', pngPath, S + 'px');

assets/icons/build/extract.js

@@ -0,0 +1,78 @@
+'use strict';
+// Extract the glyph outlines the site icons and the og-image wordmark need from a
+// grotesque font (LiberationSans = Arial-metric, matching the game's system-ui/Arial
+// stack) and emit cubic-bezier contours per character, baseline at y=0, y-down,
+// plus the advance width so generate.js can lay out words without the font.
+// Same outline conversion as ../../vk/build/extract.js, generalised to a char set.
+const opentype = require('opentype.js');
+const fs = require('fs');
+
+const FONT = process.argv[2] || '/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf';
+const b = fs.readFileSync(FONT);
+const font = opentype.parse(b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength));
+const FS = 1000; // em scale
+
+// The tile glyphs («Э», «8») + every character of the og-image wordmark lines
+// («Эрудит», «Скрэббл — игра в слова»). The space carries only an advance.
+const CHARS = [...new Set('Э8рудитСкэббл—игра в слова')];
+
+function glyphData(ch) {
+  const g = font.charToGlyph(ch);
+  const p = g.getPath(0, 0, FS); // baseline at y=0, y-down
+  const contours = [];
+  let cur = null, prev = null;
+  for (const c of p.commands) {
+    if (c.type === 'M') {
+      if (cur) contours.push(cur);
+      cur = [{ v: [c.x, c.y], i: [c.x, c.y], o: [c.x, c.y] }];
+      prev = { x: c.x, y: c.y };
+    } else if (c.type === 'L') {
+      cur.push({ v: [c.x, c.y], i: [c.x, c.y], o: [c.x, c.y] });
+      prev = { x: c.x, y: c.y };
+    } else if (c.type === 'C') {
+      cur[cur.length - 1].o = [c.x1, c.y1];
+      cur.push({ v: [c.x, c.y], i: [c.x2, c.y2], o: [c.x, c.y] });
+      prev = { x: c.x, y: c.y };
+    } else if (c.type === 'Q') {
+      const c1 = [prev.x + 2 / 3 * (c.x1 - prev.x), prev.y + 2 / 3 * (c.y1 - prev.y)];
+      const c2 = [c.x + 2 / 3 * (c.x1 - c.x), c.y + 2 / 3 * (c.y1 - c.y)];
+      cur[cur.length - 1].o = c1;
+      cur.push({ v: [c.x, c.y], i: c2, o: [c.x, c.y] });
+      prev = { x: c.x, y: c.y };
+    } else if (c.type === 'Z') {
+      if (cur && cur.length > 1) {
+        const last = cur[cur.length - 1], first = cur[0];
+        if (Math.hypot(last.v[0] - first.v[0], last.v[1] - first.v[1]) < 1e-3) {
+          first.i = last.i; // fold the duplicate closing point into the first
+          cur.pop();
+        }
+      }
+      if (cur) { contours.push(cur); cur = null; }
+    }
+  }
+  if (cur) contours.push(cur);
+
+  let minx = Infinity, miny = Infinity, maxx = -Infinity, maxy = -Infinity;
+  const out = contours.map(ct => {
+    const v = [], i = [], o = [];
+    ct.forEach(pt => {
+      v.push(pt.v);
+      i.push([pt.i[0] - pt.v[0], pt.i[1] - pt.v[1]]);
+      o.push([pt.o[0] - pt.v[0], pt.o[1] - pt.v[1]]);
+      minx = Math.min(minx, pt.v[0]); maxx = Math.max(maxx, pt.v[0]);
+      miny = Math.min(miny, pt.v[1]); maxy = Math.max(maxy, pt.v[1]);
+    });
+    return { i, o, v, c: true };
+  });
+  const bbox = out.length
+    ? { x: minx, y: miny, w: maxx - minx, h: maxy - miny }
+    : { x: 0, y: 0, w: 0, h: 0 }; // the space has no outline
+  return { adv: g.advanceWidth * (FS / font.unitsPerEm), bbox, contours: out };
+}
+
+const glyphs = {};
+for (const ch of CHARS) glyphs[ch] = glyphData(ch);
+
+const out = __dirname + '/glyphs.json';
+fs.writeFileSync(out, JSON.stringify({ em: FS, glyphs }));
+console.log('wrote', out, fs.statSync(out).size, 'bytes;', CHARS.length, 'glyphs:', CHARS.join(''));

assets/icons/build/generate.js

@@ -0,0 +1,128 @@
+'use strict';
+// Site icons + the Open Graph card for the public landing, drawn from the same
+// design as ../../vk (the wooden Erudit tile: face «Э», score «8») and the app's
+// board palette (ui/src/app.css). Everything is composed as SVG from the committed
+// glyph outlines (build/extract.js -> glyphs.json), so no font is needed at build
+// time; the PNG/ICO rasters are screenshots taken with the ui package's Playwright
+// chromium (@playwright/test re-exports the browser API). Outputs go straight to
+// ui/public/:
+//   favicon.svg          96 viewBox, transparent, tile + «Э» (the score is illegible small)
+//   favicon.ico          32x32 PNG-in-ICO render of the same
+//   apple-touch-icon.png 180x180 opaque full-bleed tile (iOS masks its own corners)
+//   og-image.png         1200x630 card: tile + wordmark on the board green
+const fs = require('fs');
+const path = require('path');
+
+const G = JSON.parse(fs.readFileSync(path.join(__dirname, 'glyphs.json'), 'utf8'));
+const UI = path.resolve(__dirname, '../../../ui');
+const OUT = path.join(UI, 'public');
+
+// ---- palette (vk loader tile + app.css board tokens) ------------------------
+const FACE = '#D9B978', BORDER = '#B49559', GLYPH = '#1A1A1A';
+const BOARD_DARK = '#2a3330', TEXT = '#e7ece8', TEXT_MUTED = '#cdd6cf';
+
+// ---- glyph outlines -> SVG path data ----------------------------------------
+const r2 = n => Math.round(n * 100) / 100;
+// pathD renders one glyph's contours scaled by sc and translated by (tx, ty).
+function pathD(g, sc, tx, ty) {
+  const pt = (v, d) => `${r2(v[0] * sc + tx + d[0] * sc)} ${r2(v[1] * sc + ty + d[1] * sc)}`;
+  const Z = [0, 0];
+  return g.contours.map(ct => {
+    const n = ct.v.length;
+    let d = `M${pt(ct.v[0], Z)}`;
+    for (let k = 1; k <= n; k++) {
+      const a = k - 1, b = k % n;
+      d += `C${pt(ct.v[a], ct.o[a])} ${pt(ct.v[b], ct.i[b])} ${pt(ct.v[b], Z)}`;
+    }
+    return d + 'Z';
+  }).join('');
+}
+// glyphAt centres a glyph's bbox at (cx, cy) with the given pixel cap height, the
+// same placement rule as the vk loader's glyph(). stroke fattens it slightly.
+function glyphAt(ch, capPx, cx, cy, stroke, colour) {
+  const g = G.glyphs[ch], sc = capPx / g.bbox.h;
+  const d = pathD(g, sc, cx - (g.bbox.x + g.bbox.w / 2) * sc, cy - (g.bbox.y + g.bbox.h / 2) * sc);
+  return `<path d="${d}" fill="${colour}" stroke="${colour}" stroke-width="${r2(stroke)}"/>`;
+}
+// textLine lays out a string on a baseline from the per-glyph advances; capPx sets
+// the capital height (measured on «Э»). Returns the combined path + the width.
+function textLine(str, capPx, x, y, colour) {
+  const sc = capPx / G.glyphs['Э'].bbox.h;
+  let d = '', w = 0;
+  for (const ch of str) {
+    const g = G.glyphs[ch];
+    if (g.contours.length) d += pathD(g, sc, x + w, y);
+    w += g.adv * sc;
+  }
+  return { svg: `<path d="${d}" fill="${colour}"/>`, width: w };
+}
+// tile draws the rounded wooden tile centred at (cx, cy): size px wide/high, with
+// the vk loader's corner (6/52) and rim proportions, «Э» and optionally the «8».
+function tile(cx, cy, size, withScore) {
+  const h = size / 2, rx = size * (6 / 52), rim = size * (1.8 / 52);
+  let s = `<rect x="${r2(cx - h + rim / 2)}" y="${r2(cy - h + rim / 2)}" width="${r2(size - rim)}" height="${r2(size - rim)}" rx="${r2(rx)}" fill="${FACE}" stroke="${BORDER}" stroke-width="${r2(rim)}"/>`;
+  s += glyphAt('Э', size * (32 / 52), cx, cy - size * (1 / 52), size * (1 / 52), GLYPH);
+  if (withScore) s += glyphAt('8', size * (8.5 / 52), cx + size * (19.5 / 52), cy + size * (18.5 / 52), size * (0.5 / 52), GLYPH);
+  return s;
+}
+const svg = (w, h, body) => `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">${body}</svg>`;
+
+// ---- favicon.svg (the committed vector master) -------------------------------
+const favicon = svg(96, 96, tile(48, 48, 88, false)) + '\n';
+
+// ---- apple-touch-icon: opaque full bleed, iOS applies its own corner mask ----
+const appleTouch = svg(180, 180,
+  `<rect width="180" height="180" fill="${FACE}"/>` +
+  `<rect x="8" y="8" width="164" height="164" rx="18" fill="none" stroke="${BORDER}" stroke-width="4"/>` +
+  glyphAt('Э', 100, 90, 88, 3, GLYPH) +
+  glyphAt('8', 26, 146, 142, 1.5, GLYPH));
+
+// ---- og-image: tile + wordmark, centred as one group on the board green ------
+function ogImage() {
+  const W = 1200, H = 630, tileSize = 340, gap = 84;
+  const l1 = textLine('Эрудит', 112, 0, 0, TEXT);
+  const l2 = textLine('Скрэббл — игра в слова', 44, 0, 0, TEXT_MUTED);
+  const textW = Math.max(l1.width, l2.width);
+  const left = (W - (tileSize + gap + textW)) / 2;
+  const tx = left + tileSize + gap;
+  // Two baselines around the vertical centre; the tile centre sits between them.
+  const b1 = 295, b2 = 408;
+  const body =
+    `<rect width="${W}" height="${H}" fill="${BOARD_DARK}"/>` +
+    tile(left + tileSize / 2, H / 2, tileSize, true) +
+    textLine('Эрудит', 112, tx, b1, TEXT).svg +
+    textLine('Скрэббл — игра в слова', 44, tx, b2, TEXT_MUTED).svg;
+  console.log(`og-image: text ${Math.round(textW)}px wide, group left ${Math.round(left)}px`);
+  return svg(W, H, body);
+}
+
+// ---- rasterisation (Playwright chromium from ui/node_modules) ----------------
+async function shoot(page, markup, w, h, transparent) {
+  await page.setViewportSize({ width: w, height: h });
+  await page.setContent(`<body style="margin:0">${markup}</body>`);
+  return page.screenshot({ omitBackground: transparent });
+}
+// icoFromPNG wraps one PNG as a single-entry .ico (ICONDIR + ICONDIRENTRY + PNG).
+function icoFromPNG(png, sizePx) {
+  const h = Buffer.alloc(22);
+  h.writeUInt16LE(0, 0); h.writeUInt16LE(1, 2); h.writeUInt16LE(1, 4); // icon, 1 image
+  h.writeUInt8(sizePx, 6); h.writeUInt8(sizePx, 7);                    // 32x32
+  h.writeUInt16LE(1, 10); h.writeUInt16LE(32, 12);                     // planes, 32bpp
+  h.writeUInt32LE(png.length, 14); h.writeUInt32LE(22, 18);            // size, offset
+  return Buffer.concat([h, png]);
+}
+
+(async () => {
+  fs.writeFileSync(path.join(OUT, 'favicon.svg'), favicon);
+  const { chromium } = require(path.join(UI, 'node_modules', '@playwright/test'));
+  const browser = await chromium.launch();
+  const page = await browser.newPage();
+  const fav32 = await shoot(page, svg(32, 32, tile(16, 16, 29.33, false)), 32, 32, true);
+  fs.writeFileSync(path.join(OUT, 'favicon.ico'), icoFromPNG(fav32, 32));
+  fs.writeFileSync(path.join(OUT, 'apple-touch-icon.png'), await shoot(page, appleTouch, 180, 180, false));
+  fs.writeFileSync(path.join(OUT, 'og-image.png'), await shoot(page, ogImage(), 1200, 630, false));
+  await browser.close();
+  for (const f of ['favicon.svg', 'favicon.ico', 'apple-touch-icon.png', 'og-image.png']) {
+    console.log('wrote', path.join(OUT, f), fs.statSync(path.join(OUT, f)).size, 'bytes');
+  }
+})();

backend/Dockerfile

@@ -49,14 +49,9 @@ COPY --from=build /out/backend /usr/local/bin/backend
 # Own the seed dictionary as the nonroot runtime user (UID 65532): a named volume
 # mounted at /opt/dawg inherits this ownership on first use, so the admin console
 # can write new version subdirectories at runtime. The volume preserves uploaded
-# versions across deploys and, once seeded, is not re-seeded (ARCHITECTURE.md §5).
+# versions across deploys and, once seeded, is not re-seeded — so after bootstrap
+# every dictionary change goes through the console, not a rebuild (ARCHITECTURE.md §5).
 COPY --from=dawg --chown=65532:65532 /dawg /opt/dawg
-# A second, UNSHADOWED copy of the build's DAWGs: the /opt/dawg volume mount hides the
-# image's copy there, so this is where engine.DeliverVersion reads the build version from
-# to add it (add-only) to the volume on boot — the deploy-delivers path that lets a bumped
-# BACKEND_DICT_VERSION go live for new games without an admin upload (ARCHITECTURE.md §5).
-COPY --from=dawg --chown=65532:65532 /dawg /opt/dawg-seed
 ENV BACKEND_DICT_DIR=/opt/dawg
-ENV BACKEND_DICT_SEED_DIR=/opt/dawg-seed
 ENV BACKEND_DICT_VERSION=${DICT_VERSION}
 ENTRYPOINT ["/usr/local/bin/backend"]

backend/cmd/backend/main.go

@@ -111,12 +111,6 @@ func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
 	}
 	logger.Info("database migrations applied")
 
-	// Deliver the build's dictionary version onto the persistent volume if a redeploy
-	// bumped it (add-only; old versions in-flight games pin are untouched), so the new
-	// dictionary is resident and can be activated below without an admin upload.
-	if err := engine.DeliverVersion(cfg.Game.DictDir, cfg.Game.DictSeedDir, cfg.Game.DictVersion); err != nil {
-		return fmt.Errorf("deliver dictionary version: %w", err)
-	}
 	registry, err := engine.OpenWithVersions(cfg.Game.DictDir, cfg.Game.DictVersion)
 	if err != nil {
 		return fmt.Errorf("load dictionaries: %w", err)
@@ -124,7 +118,6 @@ func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
 	defer func() { _ = registry.Close() }()
 	logger.Info("dictionaries loaded",
 		zap.String("dir", cfg.Game.DictDir),
-		zap.String("seed_dir", cfg.Game.DictSeedDir),
 		zap.String("version", cfg.Game.DictVersion))
 
 	// Admin console: an optional backend client to the Telegram connector
@@ -154,10 +147,10 @@ func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
 	accounts := account.NewStore(db)
 	accounts.SetMetrics(tel.MeterProvider().Meter("scrabble/backend/account"))
 	games := game.NewService(game.NewStore(db), accounts, registry, cfg.Game, logger)
-	// Reconcile the active dictionary version with the registry: the build version
+	// Reconcile the persisted active dictionary version with the registry: a
-	// (delivered above) becomes active so a redeploy that bumped it goes live for new
+	// version activated through the admin console (and written to the dictionary
-	// games, except a newer version installed out-of-band through the admin console,
+	// volume) is adopted again after a restart; otherwise the configured seed
-	// which is not downgraded by a restart (docs/ARCHITECTURE.md §5).
+	// version is kept and persisted (docs/ARCHITECTURE.md §5).
 	if err := games.InitActiveVersion(ctx); err != nil {
 		return fmt.Errorf("init active dictionary version: %w", err)
 	}
@@ -290,13 +283,6 @@ func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
 	}
 	logger.Info("payments domain ready")
 
-	// Warm the public-offer price list cache so /offer/ serves the current catalog from the first
-	// request; it is reprojected lazily thereafter on any catalog edit. Non-fatal — a transient
-	// failure here only defers the projection to the first read.
-	if _, err := paymentsSvc.OfferPricing(ctx); err != nil {
-		logger.Warn("offer pricing warm failed; will project on first request", zap.Error(err))
-	}
-
 	// Wire the payments surface into the domains that consume it: the online-game hint wallet
 	// and the account-merge wallet fold. Done after the reachability check so a broken payments
 	// schema fails boot before anything depends on it.

backend/internal/account/account.go

@@ -534,7 +534,7 @@ const guestDisplayName = "Guest"
 // and history. Guests are not reused — each bootstrap mints a new account. browserTZ
 // (the client's detected "±HH:MM" UTC offset) seeds the guest's time zone, falling
 // back to the 'UTC' default when empty or malformed.
-func (s *Store) ProvisionGuest(ctx context.Context, browserTZ, language string) (Account, error) {
+func (s *Store) ProvisionGuest(ctx context.Context, browserTZ string) (Account, error) {
 	accountID, err := uuid.NewV7()
 	if err != nil {
 		return Account{}, fmt.Errorf("account: new guest id: %w", err)
@@ -543,17 +543,9 @@ func (s *Store) ProvisionGuest(ctx context.Context, browserTZ, language string)
 	if tz == "" {
 		tz = "UTC"
 	}
-	// Seed the interface language from the client's detected locale (validated to a supported
-	// one), so a fresh guest's language-dependent server content — the ad banner, bot messages —
-	// is right from first contact rather than the 'en' column default until the client's later
-	// language reconcile catches up. An unsupported or absent code keeps the 'en' default.
-	lang := supportedLanguage(language)
-	if lang == "" {
-		lang = "en"
-	}
 	stmt := table.Accounts.
-		INSERT(table.Accounts.AccountID, table.Accounts.DisplayName, table.Accounts.IsGuest, table.Accounts.TimeZone, table.Accounts.PreferredLanguage).
+		INSERT(table.Accounts.AccountID, table.Accounts.DisplayName, table.Accounts.IsGuest, table.Accounts.TimeZone).
-		VALUES(accountID, guestDisplayName, true, tz, lang).
+		VALUES(accountID, guestDisplayName, true, tz).
 		RETURNING(table.Accounts.AllColumns)
 
 	var row model.Accounts

backend/internal/adminconsole/templates/pages/catalog.gohtml

@@ -21,29 +21,7 @@
 <div><button type="submit">Add</button></div>
 </form>
 </section>
-<section class="panel"><h2>Rewarded ads (watch for chips)</h2>
-<p class="note">The chips a player earns per rewarded-video view (VK only), plus the per-day and per-hour caps that bound free chips — <strong>0 payout turns rewarded off</strong>. This is the shared reward config, not a product.</p>
-<form class="form col" method="post" action="/_gm/catalog/reward">
-<label>Chips per view <input type="number" name="reward_payout" min="0" value="{{.RewardPayout}}"></label>
-<label>Daily cap <input type="number" name="reward_daily" min="0" value="{{.RewardDailyCap}}"></label>
-<label>Hourly cap <input type="number" name="reward_hourly" min="0" value="{{.RewardHourlyCap}}"></label>
-<div><button type="submit">Save</button></div>
-</form>
-</section>
-<section class="panel"><h2>Payment availability (kill switch)</h2>
-<p class="note">Turn purchases off on a rail/channel and show the user a localized reason on their next attempt. Unchecked = off; an empty message shows a built-in &ldquo;temporarily unavailable&rdquo;. Fail-open: a rail you never touch stays on. A per-user &ldquo;allow&rdquo; override (on a user card) bypasses this switch.</p>
-{{range .Rails}}
-<form class="form col" method="post" action="/_gm/catalog/rail-status">
-<input type="hidden" name="rail" value="{{.Rail}}">
-<label><input type="checkbox" name="enabled" {{if .Enabled}}checked{{end}}> <code>{{.Rail}}</code> &mdash; purchases enabled</label>
-<label>Message RU <input type="text" name="message_ru" maxlength="200" value="{{.MessageRU}}"></label>
-<label>Message EN <input type="text" name="message_en" maxlength="200" value="{{.MessageEN}}"></label>
-<div><button type="submit">Save</button></div>
-</form>
-{{end}}
-</section>
 <section class="panel"><h2>Products</h2>
-<p class="note">Showing {{if .ShowAll}}<strong>all</strong> products (active + archived) — <a href="/_gm/catalog">active only</a>{{else}}<strong>active</strong> products — <a href="/_gm/catalog?all=1">show all (incl. archived)</a>{{end}}.</p>
 <table class="list">
 <thead><tr><th>Title</th><th>Status</th><th>Atoms</th><th>Prices</th><th></th></tr></thead>
 <tbody>

backend/internal/adminconsole/templates/pages/game_detail.gohtml

@@ -8,7 +8,6 @@
 <li><b>Dictionary</b> {{.DictVersion}}</li>
 <li><b>Status</b> {{.Status}}{{if .EndReason}} ({{.EndReason}}){{end}}</li>
 <li><b>AI game</b> {{if .VsAI}}🤖 yes{{else}}no{{end}}</li>
-<li><b>Word rule</b> {{if .MultipleWordsPerTurn}}multiple words per turn{{else}}single word per turn{{end}}</li>
 <li><b>Players</b> {{.Players}}</li>
 <li><b>To move</b> seat {{.ToMove}}</li>
 <li><b>Moves</b> {{.MoveCount}}</li>

backend/internal/adminconsole/templates/pages/user_detail.gohtml

@@ -72,24 +72,14 @@
 {{if or .Finance.Abuse .Finance.Loss}}<li><b>Refund risk</b> <span class="warn">{{if .Finance.Abuse}}abuse-flagged{{end}}{{if .Finance.Loss}} · loss {{.Finance.Loss}} chips{{end}}</span></li>{{end}}
 </ul>
 {{else}}<p class="note">no balances or benefits</p>{{end}}
-<h3>Payment override</h3>
-<form class="form" method="post" action="/_gm/users/{{.ID}}/purchase-override">
-<label>Purchases for this account
-<select name="override">
-<option value="default" {{if eq .PurchaseOverride "default"}}selected{{end}}>Default (follow the rail switch)</option>
-<option value="allow" {{if eq .PurchaseOverride "allow"}}selected{{end}}>Always allow (bypasses the rail switch only, not security)</option>
-<option value="deny" {{if eq .PurchaseOverride "deny"}}selected{{end}}>Always deny</option>
-</select></label>
-<div><button type="submit">Save</button></div>
-</form>
 <h3>Ledger</h3>
 {{$uid := .ID}}
 {{if .Finance.Ledger}}
 <table class="list">
-<thead><tr><th>Time</th><th>Kind</th><th>Source</th><th>Origin</th><th>Chips</th><th>Order</th><th>Provider</th><th>Shop</th><th>Detail</th><th></th></tr></thead>
+<thead><tr><th>Time</th><th>Kind</th><th>Source</th><th>Origin</th><th>Chips</th><th>Order</th><th>Provider</th><th>Detail</th><th></th></tr></thead>
 <tbody>
 {{range .Finance.Ledger}}
-<tr><td>{{.At}}</td><td>{{.Kind}}</td><td>{{.Source}}</td><td>{{.Origin}}</td><td>{{.ChipsDelta}}</td><td>{{if .Order}}<code>{{.Order}}</code>{{end}}</td><td>{{.Provider}}</td><td>{{.Shop}}</td><td>{{if .Snapshot}}<code>{{.Snapshot}}</code>{{end}}</td>
+<tr><td>{{.At}}</td><td>{{.Kind}}</td><td>{{.Source}}</td><td>{{.Origin}}</td><td>{{.ChipsDelta}}</td><td>{{if .Order}}<code>{{.Order}}</code>{{end}}</td><td>{{.Provider}}</td><td>{{if .Snapshot}}<code>{{.Snapshot}}</code>{{end}}</td>
 <td>{{if and (eq .Kind "fund") .Order}}<form class="form" method="post" action="/_gm/users/{{$uid}}/refund" onsubmit="return confirm('Refund this order in full? Record the money refund on the rail first; this revokes the chips (floored at 0).')"><input type="hidden" name="order_id" value="{{.Order}}"><button type="submit">Refund</button></form>{{end}}</td></tr>
 {{end}}
 </tbody>

backend/internal/adminconsole/views.go

@@ -198,9 +198,6 @@ type UserDetailView struct {
 	// Finance is the account's payments picture (balances, benefits, refund risk, ledger). Present
 	// is false when the payments domain is unwired.
 	Finance FinanceView
-	// PurchaseOverride is the account's per-account purchase override ("default"/"allow"/"deny"),
-	// shown in and edited from the user card's payment-override control.
-	PurchaseOverride string
 	// Grant is the admin-grant panel (origin picker + grantable products). Present is false when the
 	// payments domain is unwired.
 	Grant GrantFormView
@@ -235,8 +232,8 @@ type BenefitRow struct {
 }
 
 // LedgerRow is one append-only ledger entry: its kind, funding source / benefit origin, signed chip
-// delta, the product / order / provider / direct-rail shop it references (empty when none), the raw
+// delta, the product / order / provider it references (empty when none), the raw snapshot JSON and
-// snapshot JSON and the pre-formatted time.
+// the pre-formatted time.
 type LedgerRow struct {
 	Kind       string
 	Source     string
@@ -245,7 +242,6 @@ type LedgerRow struct {
 	Product    string
 	Order      string
 	Provider   string
-	Shop       string
 	Snapshot   string
 	At         string
 }
@@ -352,12 +348,8 @@ type GameDetailView struct {
 	UpdatedAt   string
 	FinishedAt  string
 	// VsAI marks an honest-AI game (shown as a 🤖 flag in the summary).
-	VsAI bool
+	VsAI  bool
-	// MultipleWordsPerTurn is the game's cross-word rule: true = standard Scrabble (every cross-word
+	Seats []SeatRow
-	// is validated and scored), false = the single-word rule (only the main word along the play
-	// direction counts). Shown in the summary so an operator can tell the rule at a glance.
-	MultipleWordsPerTurn bool
-	Seats                []SeatRow
 	// HasRobot is true when any seat is a robot, gating the robot-target caption;
 	// RobotTargetPct is the configured global play-to-win rate, in percent.
 	HasRobot       bool
@@ -681,27 +673,6 @@ type FeedbackDetailView struct {
 // CatalogView is the product-catalog list page.
 type CatalogView struct {
 	Products []ProductRow
-	// ShowAll reports whether archived products are listed alongside active ones (the active/all
-	// toggle); it drives the toggle link and the list heading.
-	ShowAll bool
-	// RewardPayout / RewardDailyCap / RewardHourlyCap are the rewarded-video config (chips earned per
-	// view and the per-day / per-hour anti-abuse caps), shown in and edited from the page's
-	// rewarded-ads form. A 0 payout means rewarded is inert.
-	RewardPayout    int
-	RewardDailyCap  int
-	RewardHourlyCap int
-	// Rails is the per-rail operational kill-switch state (enabled + per-language off-message), shown
-	// in and edited from the page's payment-availability form.
-	Rails []RailStatusRow
-}
-
-// RailStatusRow is one payment rail's operational availability in the kill-switch editor: the rail
-// key, whether purchases are enabled, and the operator's per-language off-message shown to the user.
-type RailStatusRow struct {
-	Rail      string
-	Enabled   bool
-	MessageRU string
-	MessageEN string
 }
 
 // ProductRow is one product in the catalog list: its composition, prices, the archived flag

backend/internal/config/config.go

@@ -65,9 +65,9 @@ type Config struct {
 	// RendererURL is the base URL of the internal image-render sidecar (e.g.
 	// http://renderer:8090). Empty disables the PNG export artifact.
 	RendererURL string
-	// Robokassa configures the direct-rail (RUB) payment provider — one merchant shop per channel
+	// Robokassa configures the direct-rail (RUB) payment provider. An empty MerchantLogin
-	// (D42). An empty set leaves the direct order and Result-callback endpoints unregistered.
+	// leaves the direct order and Result-callback endpoints unregistered.
-	Robokassa robokassa.Shops
+	Robokassa robokassa.Config
 }
 
 // Defaults applied when the corresponding environment variable is unset.
@@ -106,7 +106,6 @@ func Load() (Config, error) {
 	gm := game.DefaultConfig()
 	gm.DictDir = envOr("BACKEND_DICT_DIR", gm.DictDir)
 	gm.DictVersion = envOr("BACKEND_DICT_VERSION", gm.DictVersion)
-	gm.DictSeedDir = envOr("BACKEND_DICT_SEED_DIR", gm.DictSeedDir)
 	if gm.TimeoutSweepInterval, err = envDuration("BACKEND_GAME_TIMEOUT_SWEEP_INTERVAL", gm.TimeoutSweepInterval); err != nil {
 		return Config{}, err
 	}
@@ -158,19 +157,11 @@ func Load() (Config, error) {
 		AdminTo:   os.Getenv("BACKEND_ADMIN_EMAIL"),
 	}
 
-	// Robokassa direct rail: one merchant shop per channel (D42). The legacy single-shop vars seed
+	robo := robokassa.Config{
-	// the web channel so existing deploys keep working; the per-channel vars add the rest. A shop
+		MerchantLogin: os.Getenv("BACKEND_ROBOKASSA_MERCHANT_LOGIN"),
-	// with no MerchantLogin is dropped (the rail stays dormant when none is configured).
+		Password1:     os.Getenv("BACKEND_ROBOKASSA_PASSWORD1"),
-	shops := robokassa.Shops{}
+		Password2:     os.Getenv("BACKEND_ROBOKASSA_PASSWORD2"),
-	web := robokassaShop("BACKEND_ROBOKASSA_WEB")
+		IsTest:        os.Getenv("BACKEND_ROBOKASSA_TEST") == "1",
-	if web.MerchantLogin == "" {
-		web = robokassaShop("BACKEND_ROBOKASSA") // legacy single-shop credentials seed the web channel
-	}
-	if web.MerchantLogin != "" {
-		shops[robokassa.ChannelWeb] = web
-	}
-	if android := robokassaShop("BACKEND_ROBOKASSA_ANDROID"); android.MerchantLogin != "" {
-		shops[robokassa.ChannelAndroid] = android
 	}
 
 	c := Config{
@@ -190,7 +181,7 @@ func Load() (Config, error) {
 		GuestRetention:    guestRetention,
 		ExportSignKey:     os.Getenv("BACKEND_EXPORT_SIGN_KEY"),
 		RendererURL:       os.Getenv("BACKEND_RENDERER_URL"),
-		Robokassa:         shops,
+		Robokassa:         robo,
 	}
 	if err := c.validate(); err != nil {
 		return Config{}, err
@@ -243,10 +234,8 @@ func (c Config) validate() error {
 			return fmt.Errorf("config: BACKEND_PUBLIC_BASE_URL %q must be an absolute URL (scheme://host)", c.PublicBaseURL)
 		}
 	}
-	for channel, shop := range c.Robokassa {
+	if c.Robokassa.MerchantLogin != "" && (c.Robokassa.Password1 == "" || c.Robokassa.Password2 == "") {
-		if shop.Password1 == "" || shop.Password2 == "" {
+		return fmt.Errorf("config: BACKEND_ROBOKASSA_PASSWORD1 and BACKEND_ROBOKASSA_PASSWORD2 must be set when BACKEND_ROBOKASSA_MERCHANT_LOGIN is")
-			return fmt.Errorf("config: robokassa shop %q: password1 and password2 must be set when its merchant login is", channel)
-		}
 	}
 	return nil
 }
@@ -287,15 +276,3 @@ func envDuration(key string, fallback time.Duration) (time.Duration, error) {
 	}
 	return d, nil
 }
-
-// robokassaShop reads a Robokassa shop's four credentials from the environment under prefix (e.g.
-// "BACKEND_ROBOKASSA_WEB" → _MERCHANT_LOGIN / _PASSWORD1 / _PASSWORD2 / _TEST). A missing
-// MerchantLogin yields a zero Config the caller drops.
-func robokassaShop(prefix string) robokassa.Config {
-	return robokassa.Config{
-		MerchantLogin: os.Getenv(prefix + "_MERCHANT_LOGIN"),
-		Password1:     os.Getenv(prefix + "_PASSWORD1"),
-		Password2:     os.Getenv(prefix + "_PASSWORD2"),
-		IsTest:        os.Getenv(prefix+"_TEST") == "1",
-	}
-}

backend/internal/engine/deliver.go

@@ -1,92 +0,0 @@
-package engine
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-// DeliverVersion makes the build's dictionary version resident on the persistent
-// dictionary volume without disturbing the versions in-flight games already pin.
-//
-// The volume is seeded from the image once and never re-seeded, and the image's
-// /opt/dawg is shadowed by that volume mount, so a redeploy that bumped
-// BACKEND_DICT_VERSION cannot otherwise make the new DAWGs reachable at runtime.
-// The image therefore keeps an unshadowed read-only copy at seedDir, and this
-// copies it into dictDir/<version>/ when the version is not already present —
-// neither the flat seed's own recorded label nor an existing version
-// subdirectory. It is add-only and idempotent: the flat seed and any prior admin
-// uploads are never touched, so old games keep the version they pin while the new
-// one becomes resident and activatable (see game.Service.InitActiveVersion). A
-// blank seedDir disables delivery (the pre-existing seed-only behaviour).
-func DeliverVersion(dictDir, seedDir, version string) error {
-	if seedDir == "" || version == "" {
-		return nil
-	}
-	target := filepath.Join(dictDir, version)
-	if _, err := os.Stat(target); err == nil {
-		return nil // already delivered on a prior boot
-	} else if !errors.Is(err, os.ErrNotExist) {
-		return fmt.Errorf("engine: stat delivered dictionary %s: %w", target, err)
-	}
-	// A fresh volume is populated from the image and recorded as this version by the
-	// marker: it is the flat dir, so there is nothing to deliver. resolveSeedVersion
-	// records the label on first use, matching OpenWithVersions.
-	seed, err := resolveSeedVersion(dictDir, version)
-	if err != nil {
-		return err
-	}
-	if seed == version {
-		return nil
-	}
-	// Stage into a dot-prefixed directory (skipped by OpenWithVersions' version scan)
-	// then rename, so a crash mid-copy never leaves a half-populated version subdir.
-	staging := filepath.Join(dictDir, ".staging-deliver-"+version)
-	if err := os.RemoveAll(staging); err != nil {
-		return fmt.Errorf("engine: clear deliver staging %s: %w", staging, err)
-	}
-	if err := os.MkdirAll(staging, 0o755); err != nil {
-		return fmt.Errorf("engine: create deliver staging %s: %w", staging, err)
-	}
-	for _, file := range dictFiles {
-		src := filepath.Join(seedDir, file)
-		if _, err := os.Stat(src); errors.Is(err, os.ErrNotExist) {
-			continue // a variant absent from the seed is simply absent under this version
-		} else if err != nil {
-			_ = os.RemoveAll(staging)
-			return fmt.Errorf("engine: stat seed dawg %s: %w", src, err)
-		}
-		if err := copyFile(src, filepath.Join(staging, file)); err != nil {
-			_ = os.RemoveAll(staging)
-			return err
-		}
-	}
-	if err := os.Rename(staging, target); err != nil {
-		_ = os.RemoveAll(staging)
-		return fmt.Errorf("engine: publish delivered dictionary %s: %w", target, err)
-	}
-	return nil
-}
-
-// copyFile copies a single file, truncating the destination.
-func copyFile(src, dst string) error {
-	in, err := os.Open(src)
-	if err != nil {
-		return fmt.Errorf("engine: open %s: %w", src, err)
-	}
-	defer func() { _ = in.Close() }()
-	out, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
-	if err != nil {
-		return fmt.Errorf("engine: create %s: %w", dst, err)
-	}
-	if _, err := io.Copy(out, in); err != nil {
-		_ = out.Close()
-		return fmt.Errorf("engine: copy %s -> %s: %w", src, dst, err)
-	}
-	if err := out.Close(); err != nil {
-		return fmt.Errorf("engine: finalise %s: %w", dst, err)
-	}
-	return nil
-}

backend/internal/engine/deliver_test.go

@@ -1,68 +0,0 @@
-package engine
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestDeliverVersion(t *testing.T) {
-	// A blank seed directory disables delivery (the pre-existing seed-only behaviour).
-	if err := DeliverVersion(t.TempDir(), "", "v1.3.1"); err != nil {
-		t.Fatalf("blank seedDir: %v", err)
-	}
-
-	// An existing volume flat-seeded as v1.3.0 gets v1.3.1 delivered as a subdirectory,
-	// add-only: the flat seed's marker is left intact and the new version's DAWGs land.
-	dict := t.TempDir()
-	seed := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dict, seedMarkerFile), []byte("v1.3.0\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	for _, f := range dictFiles {
-		if err := os.WriteFile(filepath.Join(seed, f), []byte("dawg:"+f), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := DeliverVersion(dict, seed, "v1.3.1"); err != nil {
-		t.Fatalf("deliver v1.3.1: %v", err)
-	}
-	for _, f := range dictFiles {
-		got, err := os.ReadFile(filepath.Join(dict, "v1.3.1", f))
-		if err != nil {
-			t.Fatalf("delivered %s: %v", f, err)
-		}
-		if string(got) != "dawg:"+f {
-			t.Errorf("delivered %s = %q, want the seed bytes", f, got)
-		}
-	}
-	if m, _ := os.ReadFile(filepath.Join(dict, seedMarkerFile)); string(m) != "v1.3.0\n" {
-		t.Errorf("flat seed marker relabelled to %q (delivery must be add-only)", m)
-	}
-	// Idempotent: a second call is a no-op and leaves no staging directory behind.
-	if err := DeliverVersion(dict, seed, "v1.3.1"); err != nil {
-		t.Fatalf("re-deliver v1.3.1: %v", err)
-	}
-	if entries, _ := os.ReadDir(dict); hasStaging(entries) {
-		t.Errorf("a staging directory survived delivery")
-	}
-
-	// On a fresh directory the build version becomes the flat seed, so nothing is delivered
-	// as a redundant subdirectory.
-	fresh := t.TempDir()
-	if err := DeliverVersion(fresh, seed, "v1.3.1"); err != nil {
-		t.Fatalf("fresh deliver: %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(fresh, "v1.3.1")); !os.IsNotExist(err) {
-		t.Errorf("fresh volume got a redundant v1.3.1 subdir; it should be the flat seed")
-	}
-}
-
-func hasStaging(entries []os.DirEntry) bool {
-	for _, e := range entries {
-		if len(e.Name()) >= len(".staging") && e.Name()[:len(".staging")] == ".staging" {
-			return true
-		}
-	}
-	return false
-}

backend/internal/engine/seedmarker.go

@@ -25,11 +25,11 @@ const seedMarkerFile = ".seed_version"
 //     BACKEND_DICT_VERSION) and return it — the seed of a fresh volume;
 //   - already-seeded directory: return the recorded marker and ignore bootVersion.
 //
-// So a later build seed never relabels the already-seeded flat bytes — which would void
+// So bumping the build seed on a live volume is a harmless no-op (it only takes
-// games pinned to the prior label and mis-serve new ones. The new build version is instead
+// effect on a future fresh volume) instead of relabelling the already-seeded bytes —
-// delivered as a NEW subdirectory (DeliverVersion) and made active (Service.InitActiveVersion),
+// which would void games pinned to the prior label and mis-serve new ones. New games
-// so a redeploy still moves new games to it while old games keep the flat label. New games
+// still pin the active version (DB-persisted, set by the admin console), which is the
-// pin the active version (DB-persisted); a console upload can also set it out-of-band.
+// real way a running contour moves to a new release.
 //
 // A directory that cannot be written makes the first record fail; that also breaks
 // the admin console (which writes version subdirectories here), so the error is

backend/internal/game/config.go

@@ -18,13 +18,6 @@ type Config struct {
 	// DictVersion labels the dictionary version new games pin. Sourced from
 	// BACKEND_DICT_VERSION.
 	DictVersion string
-	// DictSeedDir holds the image's read-only copy of the build's DictVersion DAWGs,
-	// on a path the persistent DictDir volume does NOT shadow. On boot the backend
-	// delivers this version into DictDir/<DictVersion>/ if absent (add-only), so a
-	// redeploy that bumped DICT_VERSION makes the new dictionary resident and activatable
-	// without disturbing the versions in-flight games already pin. Sourced from
-	// BACKEND_DICT_SEED_DIR; empty disables delivery (the pre-existing seed-only behaviour).
-	DictSeedDir string
 	// TimeoutSweepInterval is how often the sweeper scans for overdue turns.
 	// Sourced from BACKEND_GAME_TIMEOUT_SWEEP_INTERVAL.
 	TimeoutSweepInterval time.Duration

backend/internal/game/service.go

@@ -232,31 +232,21 @@ func (svc *Service) ActiveVersion() string {
 }
 
 // InitActiveVersion reconciles the persisted active dictionary version with the
-// registry at startup and makes the build's version (BACKEND_DICT_VERSION, delivered
+// registry at startup. If a version was persisted and is resident, it becomes the
-// resident by engine.DeliverVersion) authoritative: a redeploy that bumped the build
+// active version; otherwise the configured seed version is kept and persisted as
-// version thus activates it for new games without any admin step, while old games keep
+// the initial active version. Call once during wiring, before serving traffic.
-// the version they pin. The one exception is a version installed out-of-band through
-// the admin console that is NEWER than the build version and still resident — it is
-// kept, so a restart on an older image never downgrades a hotfix. A build version that
-// is not resident (delivery disabled or a partial state) falls back to a resident
-// persisted version. The chosen version is persisted so the admin console reflects it.
-// Call once during wiring, before serving traffic.
 func (svc *Service) InitActiveVersion(ctx context.Context) error {
 	persisted, ok, err := svc.store.GetActiveDictVersion(ctx)
 	if err != nil {
 		return err
 	}
-	target := svc.activeVersion() // the build seed version (config.DictVersion)
+	if ok && svc.versionResident(persisted) {
-	if ok && svc.versionResident(persisted) && compareDictVersions(persisted, target) > 0 {
+		svc.verMu.Lock()
-		target = persisted // a newer out-of-band install wins over the build version
+		svc.version = persisted
+		svc.verMu.Unlock()
+		return nil
 	}
-	if !svc.versionResident(target) && ok && svc.versionResident(persisted) {
+	return svc.store.SetActiveDictVersion(ctx, svc.activeVersion())
-		target = persisted // the build version is unloadable — keep a resident one
-	}
-	svc.verMu.Lock()
-	svc.version = target
-	svc.verMu.Unlock()
-	return svc.store.SetActiveDictVersion(ctx, target)
 }
 
 // SetActiveVersion records version as the active dictionary version, persisting it

backend/internal/game/version.go

@@ -1,45 +0,0 @@
-package game
-
-import (
-	"strconv"
-	"strings"
-)
-
-// compareDictVersions orders two dictionary version labels of the shape "vMAJOR.MINOR.PATCH"
-// numerically, returning -1, 0 or +1 as a is less than, equal to or greater than b. Labels
-// that do not parse fall back to a byte comparison, so the ordering is always total (a mixed
-// or malformed pair never crashes the boot-time active-version reconcile).
-func compareDictVersions(a, b string) int {
-	pa, oka := parseDictVersion(a)
-	pb, okb := parseDictVersion(b)
-	if !oka || !okb {
-		return strings.Compare(a, b)
-	}
-	for i := range pa {
-		if pa[i] != pb[i] {
-			if pa[i] < pb[i] {
-				return -1
-			}
-			return 1
-		}
-	}
-	return 0
-}
-
-// parseDictVersion parses a "vMAJOR.MINOR.PATCH" label into its three numeric parts, reporting
-// whether it matched that shape.
-func parseDictVersion(v string) ([3]int, bool) {
-	parts := strings.Split(strings.TrimPrefix(v, "v"), ".")
-	if len(parts) != 3 {
-		return [3]int{}, false
-	}
-	var out [3]int
-	for i, p := range parts {
-		n, err := strconv.Atoi(p)
-		if err != nil {
-			return [3]int{}, false
-		}
-		out[i] = n
-	}
-	return out, true
-}

backend/internal/game/version_test.go

@@ -1,37 +0,0 @@
-package game
-
-import "testing"
-
-func TestCompareDictVersions(t *testing.T) {
-	cases := []struct {
-		a, b string
-		want int
-	}{
-		{"v1.3.0", "v1.3.1", -1},
-		{"v1.3.1", "v1.3.0", 1},
-		{"v1.3.1", "v1.3.1", 0},
-		{"v1.3.9", "v1.3.10", -1}, // numeric, not lexical
-		{"v1.10.0", "v1.9.0", 1},
-		{"v2.0.0", "v1.9.9", 1},
-		{"1.3.1", "v1.3.1", 0}, // the leading v is optional
-		// Non-semver falls back to a byte comparison, keeping the ordering total.
-		{"weird", "weird", 0},
-		{"a", "b", -1},
-	}
-	for _, c := range cases {
-		if got := compareDictVersions(c.a, c.b); sign(got) != c.want {
-			t.Errorf("compareDictVersions(%q, %q) = %d, want sign %d", c.a, c.b, got, c.want)
-		}
-	}
-}
-
-func sign(n int) int {
-	switch {
-	case n < 0:
-		return -1
-	case n > 0:
-		return 1
-	default:
-		return 0
-	}
-}

backend/internal/inttest/account_test.go

@@ -229,36 +229,21 @@ func TestProvisionSeedsTimeZone(t *testing.T) {
 		t.Errorf("TimeZone = %q, want UTC fallback for a malformed offset", bad.TimeZone)
 	}
 
-	// A guest is seeded its detected offset and interface language; an empty offset keeps the
+	// A guest is seeded its detected offset; an empty one keeps the UTC default.
-	// UTC default and an empty/unsupported language keeps the 'en' default.
+	guest, err := store.ProvisionGuest(ctx, "-05:30")
-	guest, err := store.ProvisionGuest(ctx, "-05:30", "ru")
 	if err != nil {
 		t.Fatalf("provision guest: %v", err)
 	}
 	if guest.TimeZone != "-05:30" {
 		t.Errorf("guest TimeZone = %q, want the seeded -05:30", guest.TimeZone)
 	}
-	if guest.PreferredLanguage != "ru" {
+	plainGuest, err := store.ProvisionGuest(ctx, "")
-		t.Errorf("guest PreferredLanguage = %q, want the seeded ru", guest.PreferredLanguage)
-	}
-	plainGuest, err := store.ProvisionGuest(ctx, "", "")
 	if err != nil {
 		t.Fatalf("provision plain guest: %v", err)
 	}
 	if plainGuest.TimeZone != "UTC" {
 		t.Errorf("plain guest TimeZone = %q, want UTC default", plainGuest.TimeZone)
 	}
-	if plainGuest.PreferredLanguage != "en" {
-		t.Errorf("plain guest PreferredLanguage = %q, want en default", plainGuest.PreferredLanguage)
-	}
-	// An unsupported locale falls back to the 'en' default rather than persisting a junk value.
-	frGuest, err := store.ProvisionGuest(ctx, "", "fr-FR")
-	if err != nil {
-		t.Fatalf("provision fr guest: %v", err)
-	}
-	if frGuest.PreferredLanguage != "en" {
-		t.Errorf("unsupported-locale guest PreferredLanguage = %q, want en default", frGuest.PreferredLanguage)
-	}
 }
 
 // TestProvisionTelegramUnknownLanguageDefaults checks an unsupported Telegram

backend/internal/inttest/catalog_editor_test.go

@@ -16,7 +16,7 @@ import (
 // productByTitle finds a catalog product by its (unique in the test) title.
 func productByTitle(t *testing.T, pay *payments.Service, title string) payments.AdminProduct {
 	t.Helper()
-	all, err := pay.AdminCatalog(context.Background(), true)
+	all, err := pay.AdminCatalog(context.Background())
 	if err != nil {
 		t.Fatalf("admin catalog: %v", err)
 	}
@@ -57,7 +57,7 @@ func TestConsoleCatalogEditor(t *testing.T) {
 	if code, body := consoleDo(h, http.MethodPost, catalog, "title=cat-bad&chips=100&active=true", origin); code != http.StatusOK || !strings.Contains(body, "Invalid product") {
 		t.Fatalf("bad pack = %d, has 'Invalid product' = %v", code, strings.Contains(body, "Invalid product"))
 	}
-	if _, err := pay.AdminCatalog(ctx, true); err != nil {
+	if _, err := pay.AdminCatalog(ctx); err != nil {
 		t.Fatalf("catalog: %v", err)
 	}
 
@@ -95,59 +95,3 @@ func TestConsoleCatalogEditor(t *testing.T) {
 		t.Fatalf("delete transacted = %d, has 'Cannot delete' = %v", code, strings.Contains(body, "Cannot delete"))
 	}
 }
-
-// TestConsoleCatalogActiveToggle checks the catalog console lists only active products by default and
-// includes the archived ones under ?all=1 (the active/all toggle).
-func TestConsoleCatalogActiveToggle(t *testing.T) {
-	srv, _, _ := bannerServer(t)
-	h := srv.Handler()
-	const origin = "http://admin.test"
-	const catalog = "http://admin.test/_gm/catalog"
-
-	// An active value and an archived one (created without the active flag).
-	if code, _ := consoleDo(h, http.MethodPost, catalog, "title=toggle-active&hints=5&price_chip=50&active=true", origin); code != http.StatusOK {
-		t.Fatal("create active failed")
-	}
-	if code, _ := consoleDo(h, http.MethodPost, catalog, "title=toggle-archived&hints=9&price_chip=90", origin); code != http.StatusOK {
-		t.Fatal("create archived failed")
-	}
-
-	// Default view: active only.
-	if _, body := consoleDo(h, http.MethodGet, catalog, "", ""); !strings.Contains(body, "toggle-active") || strings.Contains(body, "toggle-archived") {
-		t.Errorf("default view: active listed=%v, archived listed=%v (want true/false)",
-			strings.Contains(body, "toggle-active"), strings.Contains(body, "toggle-archived"))
-	}
-
-	// ?all=1: active and archived.
-	if _, body := consoleDo(h, http.MethodGet, catalog+"?all=1", "", ""); !strings.Contains(body, "toggle-active") || !strings.Contains(body, "toggle-archived") {
-		t.Errorf("all view: active listed=%v, archived listed=%v (want true/true)",
-			strings.Contains(body, "toggle-active"), strings.Contains(body, "toggle-archived"))
-	}
-}
-
-// TestConsoleRewardConfig checks the rewarded-ads config form on the catalog page: a POST updates the
-// payout and caps, the page pre-fills the current values, and a negative value is refused.
-func TestConsoleRewardConfig(t *testing.T) {
-	srv, _, pay := bannerServer(t)
-	h := srv.Handler()
-	const origin = "http://admin.test"
-	const reward = "http://admin.test/_gm/catalog/reward"
-
-	// Set the payout and caps.
-	if code, body := consoleDo(h, http.MethodPost, reward, "reward_payout=7&reward_daily=40&reward_hourly=9", origin); code != http.StatusOK || !strings.Contains(body, "Saved") {
-		t.Fatalf("set reward = %d, has 'Saved' = %v", code, strings.Contains(body, "Saved"))
-	}
-	if payout, daily, hourly, err := pay.RewardConfig(context.Background()); err != nil || payout != 7 || daily != 40 || hourly != 9 {
-		t.Fatalf("reward config = %d/%d/%d (err %v), want 7/40/9", payout, daily, hourly, err)
-	}
-
-	// The catalog page renders the form pre-filled with the current payout.
-	if _, body := consoleDo(h, http.MethodGet, "http://admin.test/_gm/catalog", "", ""); !strings.Contains(body, "reward_payout") || !strings.Contains(body, `value="7"`) {
-		t.Error("catalog page did not render the reward form with the current payout")
-	}
-
-	// A negative value is refused (the service validates non-negativity).
-	if code, body := consoleDo(h, http.MethodPost, reward, "reward_payout=-1", origin); code != http.StatusOK || !strings.Contains(body, "non-negative") {
-		t.Errorf("negative payout = %d, has 'non-negative' = %v", code, strings.Contains(body, "non-negative"))
-	}
-}

backend/internal/inttest/delete_test.go

@@ -216,7 +216,7 @@ func TestConfirmCodeClearsGuest(t *testing.T) {
 	mailer := &capturingMailer{}
 	svc := account.NewEmailService(store, mailer, "https://erudit-game.ru")
 
-	guest, err := store.ProvisionGuest(ctx, "", "")
+	guest, err := store.ProvisionGuest(ctx, "")
 	if err != nil {
 		t.Fatalf("provision guest: %v", err)
 	}

backend/internal/inttest/dictionary_update_test.go

@@ -103,31 +103,14 @@ func TestDictionaryUpdateFlow(t *testing.T) {
 		t.Errorf("installed dawg missing on disk: %v", err)
 	}
 
-	// The choice survives a restart on the SAME build: an out-of-band admin install newer
+	// The choice survives a restart: a fresh service over the same DB and registry
-	// than the build version is not downgraded (a restart on an older image keeps the hotfix).
+	// re-adopts the persisted active version.
 	restarted := newGameServiceOn(dir, "v1.0.0", reg)
 	if err := restarted.InitActiveVersion(ctx); err != nil {
 		t.Fatalf("restart init: %v", err)
 	}
 	if got := restarted.ActiveVersion(); got != "v9.9.9" {
-		t.Errorf("restarted active version = %q, want v9.9.9 (a newer out-of-band install is kept)", got)
+		t.Errorf("restarted active version = %q, want v9.9.9 (persisted)", got)
-	}
-
-	// A redeploy that delivered a build version NEWER than the out-of-band one activates it
-	// for new games without any admin step (the deploy-delivers path — docs/ARCHITECTURE.md §5).
-	if _, err := reg.LoadAvailable(dir, "v10.0.0"); err != nil {
-		t.Fatalf("make v10.0.0 resident: %v", err)
-	}
-	deployed := newGameServiceOn(dir, "v10.0.0", reg)
-	if err := deployed.InitActiveVersion(ctx); err != nil {
-		t.Fatalf("deploy init: %v", err)
-	}
-	if got := deployed.ActiveVersion(); got != "v10.0.0" {
-		t.Errorf("deployed active version = %q, want v10.0.0 (a newer build version wins)", got)
-	}
-	// Restore the out-of-band active version so the assertions below still read v9.9.9.
-	if err := restarted.SetActiveVersion(ctx, "v9.9.9"); err != nil {
-		t.Fatalf("restore active: %v", err)
 	}
 
 	// New games pin the new version; the in-progress game keeps its own, still resident.

backend/internal/inttest/email_test.go

@@ -431,7 +431,7 @@ func TestConfirmByTokenLinkClearsGuest(t *testing.T) {
 	store := account.NewStore(testDB)
 	mailer := &capturingMailer{}
 	svc := account.NewEmailService(store, mailer, "https://erudit-game.ru")
-	guest, err := store.ProvisionGuest(ctx, "", "")
+	guest, err := store.ProvisionGuest(ctx, "")
 	if err != nil {
 		t.Fatalf("provision guest: %v", err)
 	}

backend/internal/inttest/helpers.go

@@ -154,7 +154,7 @@ func provisionAccount(t *testing.T) uuid.UUID {
 // provisionGuest creates a fresh ephemeral guest account and returns its id.
 func provisionGuest(t *testing.T) uuid.UUID {
 	t.Helper()
-	acc, err := account.NewStore(testDB).ProvisionGuest(context.Background(), "", "")
+	acc, err := account.NewStore(testDB).ProvisionGuest(context.Background(), "")
 	if err != nil {
 		t.Fatalf("provision guest: %v", err)
 	}

backend/internal/inttest/merge_test.go

@@ -347,10 +347,8 @@ func TestAccountLinkEmailMergeIntoCaller(t *testing.T) {
 	}
 }
 
-// TestAccountLinkGuestInversion auto-merges a guest initiator into the durable account that
+// TestAccountLinkGuestInversion merges a guest initiator into the durable account
-// owns the email AT THE CONFIRM STEP (no merge confirmation): the guest is retired, the durable
+// that owns the email: the durable account wins and a fresh session is minted.
-// account wins and a fresh session is minted for it (the client adopts the switch and lands on
-// the durable account as if it simply logged in).
 func TestAccountLinkGuestInversion(t *testing.T) {
 	ctx := context.Background()
 	store := account.NewStore(testDB)
@@ -366,18 +364,17 @@ func TestAccountLinkGuestInversion(t *testing.T) {
 		t.Fatalf("request: %v", err)
 	}
 	code := sixDigit.FindString(mailer.lastBody)
-	confirm, err := links.ConfirmEmail(ctx, guest, email, code)
+	if _, err := links.ConfirmEmail(ctx, guest, email, code); err != nil {
-	if err != nil {
 		t.Fatalf("confirm: %v", err)
 	}
-	// A guest initiator does not get a MergeRequired confirmation — the merge runs inline.
+	merge, err := links.MergeEmail(ctx, guest, email, code)
-	if !confirm.Merged || confirm.MergeRequired {
+	if err != nil {
-		t.Fatalf("confirm = %+v, want an inline (auto) merge", confirm)
+		t.Fatalf("merge: %v", err)
 	}
-	if confirm.Merge.PrimaryID != durable {
+	if merge.PrimaryID != durable {
-		t.Fatalf("primary = %s, want durable %s", confirm.Merge.PrimaryID, durable)
+		t.Fatalf("primary = %s, want durable %s", merge.PrimaryID, durable)
 	}
-	if confirm.Merge.SwitchedToken == "" {
+	if merge.SwitchedToken == "" {
 		t.Error("a guest initiator whose durable counterpart wins must get a switched session token")
 	}
 	if mergedInto(t, guest) != durable {
@@ -388,33 +385,6 @@ func TestAccountLinkGuestInversion(t *testing.T) {
 	}
 }
 
-// TestAccountLinkGuestAutoMergeActiveGameConflict guards that a guest's auto-merge is REFUSED
-// (not silently swallowed) at the confirm step when the guest and the durable account share an
-// active game: the caller surfaces ErrActiveGameConflict (mapped to a clear "finish that game
-// first" message) rather than seating one player against themselves.
-func TestAccountLinkGuestAutoMergeActiveGameConflict(t *testing.T) {
-	ctx := context.Background()
-	mailer := &capturingMailer{}
-	links := newLinkService(mailer)
-
-	durable := provisionAccount(t)
-	email := "conflict-" + uuid.NewString() + "@example.com"
-	bindEmailIdentity(t, durable, email)
-	guest := provisionGuest(t)
-	seatGame(t, []uuid.UUID{durable, guest}, 24*time.Hour) // an active game the two share
-
-	if err := links.RequestEmail(ctx, guest, email); err != nil {
-		t.Fatalf("request: %v", err)
-	}
-	code := sixDigit.FindString(mailer.lastBody)
-	if _, err := links.ConfirmEmail(ctx, guest, email, code); err != accountmerge.ErrActiveGameConflict {
-		t.Fatalf("confirm = %v, want ErrActiveGameConflict surfaced by the auto-merge", err)
-	}
-	if mergedInto(t, guest) != uuid.Nil {
-		t.Error("a refused auto-merge must not tombstone the guest")
-	}
-}
-
 // TestAccountLinkFreeVK binds a free VK identity (gateway-validated, no code) and
 // promotes a guest to durable — the ConfirmVK counterpart of the free-email case.
 func TestAccountLinkFreeVK(t *testing.T) {

backend/internal/inttest/payment_availability_test.go

@@ -1,83 +0,0 @@
-//go:build integration
-
-package inttest
-
-import (
-	"context"
-	"testing"
-
-	"github.com/google/uuid"
-
-	"scrabble/backend/internal/payments"
-)
-
-// TestPaymentAvailabilityKillSwitch exercises the per-rail kill switch + the per-account override
-// end-to-end against Postgres: fail-open, a disabled rail with a localized message, per-rail
-// granularity, and the allow/deny/default overrides.
-func TestPaymentAvailabilityKillSwitch(t *testing.T) {
-	ctx := context.Background()
-	svc := newPaymentsService()
-	acc := uuid.New()
-
-	// Fail-open: an untouched rail is enabled.
-	if ok, _, err := svc.CanPurchase(ctx, acc, payments.RailDirectWeb, "en"); err != nil || !ok {
-		t.Fatalf("fail-open: CanPurchase = %v/%v, want true", ok, err)
-	}
-
-	// Disable the web rail with a per-language message → blocked with that message, localized.
-	if err := svc.SetRailStatus(ctx, payments.RailDirectWeb, payments.RailAvailability{MessageRU: "Чиним", MessageEN: "Fixing"}); err != nil {
-		t.Fatalf("set rail status: %v", err)
-	}
-	if ok, reason, err := svc.CanPurchase(ctx, acc, payments.RailDirectWeb, "ru"); err != nil || ok || reason != "Чиним" {
-		t.Fatalf("disabled rail (ru): CanPurchase = %v/%q/%v, want false/Чиним", ok, reason, err)
-	}
-	if ok, reason, _ := svc.CanPurchase(ctx, acc, payments.RailDirectWeb, "en"); ok || reason != "Fixing" {
-		t.Fatalf("disabled rail (en): = %v/%q, want false/Fixing", ok, reason)
-	}
-	// Per-rail granularity: another rail stays enabled.
-	if ok, _, _ := svc.CanPurchase(ctx, acc, payments.RailDirectAndroid, "en"); !ok {
-		t.Fatalf("android rail should stay enabled")
-	}
-
-	// A per-account "allow" override bypasses the disabled rail.
-	if err := svc.SetPurchaseOverride(ctx, acc, payments.OverrideAllow); err != nil {
-		t.Fatalf("set override allow: %v", err)
-	}
-	if ok, _, _ := svc.CanPurchase(ctx, acc, payments.RailDirectWeb, "en"); !ok {
-		t.Fatalf("allow override should bypass the disabled rail")
-	}
-	if ov, err := svc.PurchaseOverrideFor(ctx, acc); err != nil || ov != payments.OverrideAllow {
-		t.Fatalf("PurchaseOverrideFor = %v/%v, want allow", ov, err)
-	}
-
-	// A "deny" override blocks even an enabled rail.
-	if err := svc.SetPurchaseOverride(ctx, acc, payments.OverrideDeny); err != nil {
-		t.Fatalf("set override deny: %v", err)
-	}
-	if ok, reason, _ := svc.CanPurchase(ctx, acc, payments.RailDirectAndroid, "en"); ok || reason == "" {
-		t.Fatalf("deny override should block the enabled android rail with a reason, got %v/%q", ok, reason)
-	}
-
-	// Clearing the override (default) restores rail-driven behaviour.
-	if err := svc.SetPurchaseOverride(ctx, acc, payments.OverrideDefault); err != nil {
-		t.Fatalf("clear override: %v", err)
-	}
-	if ov, _ := svc.PurchaseOverrideFor(ctx, acc); ov != payments.OverrideDefault {
-		t.Fatalf("after clear, override = %v, want default", ov)
-	}
-	if ok, _, _ := svc.CanPurchase(ctx, acc, payments.RailDirectAndroid, "en"); !ok {
-		t.Fatalf("after clearing override, android rail should be enabled again")
-	}
-
-	// RailStatuses reflects the stored web-rail change and fills the rest fail-open.
-	all, err := svc.RailStatuses(ctx)
-	if err != nil {
-		t.Fatalf("rail statuses: %v", err)
-	}
-	if all[payments.RailDirectWeb].Enabled {
-		t.Fatalf("web rail should read disabled")
-	}
-	if !all[payments.RailVK].Enabled {
-		t.Fatalf("untouched vk rail should read enabled")
-	}
-}

backend/internal/inttest/payments_catalog_test.go

@@ -4,7 +4,6 @@ package inttest
 
 import (
 	"context"
-	"strings"
 	"testing"
 
 	"github.com/google/uuid"
@@ -112,44 +111,3 @@ func TestPaymentsCatalogExcludesDeactivated(t *testing.T) {
 		t.Error("deactivated product must not appear in the storefront")
 	}
 }
-
-// TestOfferPricingReflectsCatalogEdits verifies the public-offer price list (§4.4) is projected from
-// the live catalog and its cache is invalidated on a catalog mutation: a newly created pack appears
-// with its per-rail prices, and archiving it through the service drops it from the next read.
-func TestOfferPricingReflectsCatalogEdits(t *testing.T) {
-	svc := newPaymentsService()
-	ctx := context.Background()
-	title := "OfferTest " + uuid.NewString()
-	id, err := svc.CreateProduct(ctx, payments.ProductInput{
-		Title: title,
-		Atoms: []payments.AtomLine{{Atom: "chips", Quantity: 50}},
-		Prices: []payments.PriceLine{
-			{Method: "direct", Currency: payments.CurrencyRUB, Amount: 20000},
-			{Method: "vk", Currency: payments.CurrencyVote, Amount: 30},
-			{Method: "telegram", Currency: payments.CurrencyStar, Amount: 100},
-		},
-	}, true)
-	if err != nil {
-		t.Fatalf("create pack: %v", err)
-	}
-
-	md, err := svc.OfferPricing(ctx)
-	if err != nil {
-		t.Fatalf("offer pricing: %v", err)
-	}
-	if row := "| " + title + " | 200.00 | 30 | 100 |"; !strings.Contains(md, row) {
-		t.Fatalf("offer pricing missing the new pack row %q\n%s", row, md)
-	}
-
-	// Archiving through the service marks the cache stale; the next read must reproject without it.
-	if err := svc.SetProductActive(ctx, id, false); err != nil {
-		t.Fatalf("archive: %v", err)
-	}
-	md, err = svc.OfferPricing(ctx)
-	if err != nil {
-		t.Fatalf("offer pricing after archive: %v", err)
-	}
-	if strings.Contains(md, title) {
-		t.Errorf("archived pack must drop from the offer pricing:\n%s", md)
-	}
-}

backend/internal/inttest/userlist_test.go

@@ -26,7 +26,7 @@ func TestUserListFilter(t *testing.T) {
 	if err != nil {
 		t.Fatalf("provision robot: %v", err)
 	}
-	guest, err := st.ProvisionGuest(ctx, "", "")
+	guest, err := st.ProvisionGuest(ctx, "")
 	if err != nil {
 		t.Fatalf("provision guest: %v", err)
 	}

backend/internal/link/service.go

@@ -31,39 +31,13 @@ func NewService(emails *account.EmailService, accounts *account.Store, merger *a
 	return &Service{emails: emails, accounts: accounts, merger: merger, sessions: sessions}
 }
 
-// ConfirmResult reports the outcome of a confirm step. Exactly one of Linked,
+// ConfirmResult reports the outcome of a confirm step. Exactly one of Linked or
-// MergeRequired or Merged is set. SecondaryID is the account to be retired when a merge
+// MergeRequired is set; SecondaryID is the account to be retired when a merge is
-// is required (the caller renders an irreversible-merge confirmation from it). Merged is
+// required (the caller renders an irreversible-merge confirmation from it).
-// set when the caller was a guest, so the merge ran inline (see confirmOrAutoMerge) and
-// Merge carries its result (the switched-session token for the surviving durable account).
 type ConfirmResult struct {
 	Linked        bool
 	MergeRequired bool
 	SecondaryID   uuid.UUID
-	Merged        bool
-	Merge         MergeResult
-}
-
-// confirmOrAutoMerge decides a required merge at the confirm step. A durable caller gets
-// the explicit MergeRequired confirmation (consolidating two real accounts is irreversible
-// and consequential — the user must see it). A GUEST caller does not: by the guest-primary
-// rule the durable other account survives and the ephemeral guest is retired, folding its
-// games/wallet/stats in — from the user's side it is simply "logged into my account", so the
-// merge runs inline and the client just adopts the switched session. The active-game guard can
-// still refuse (accountmerge.ErrActiveGameConflict), surfaced to the caller unchanged.
-func (s *Service) confirmOrAutoMerge(ctx context.Context, callerID, owner uuid.UUID) (ConfirmResult, error) {
-	caller, err := s.accounts.GetByID(ctx, callerID)
-	if err != nil {
-		return ConfirmResult{}, err
-	}
-	if !caller.IsGuest {
-		return ConfirmResult{MergeRequired: true, SecondaryID: owner}, nil
-	}
-	res, err := s.merge(ctx, callerID, owner)
-	if err != nil {
-		return ConfirmResult{}, err
-	}
-	return ConfirmResult{Merged: true, Merge: res}, nil
 }
 
 // MergeResult reports a completed merge. PrimaryID is the surviving account.
@@ -93,7 +67,7 @@ func (s *Service) ConfirmEmail(ctx context.Context, accountID uuid.UUID, email,
 		}
 		return ConfirmResult{Linked: true}, nil
 	}
-	return s.confirmOrAutoMerge(ctx, accountID, owner)
+	return ConfirmResult{MergeRequired: true, SecondaryID: owner}, nil
 }
 
 // MergeEmail re-verifies the code and merges the address's account into the
@@ -129,7 +103,7 @@ func (s *Service) ConfirmTelegram(ctx context.Context, callerID uuid.UUID, exter
 	if owner == callerID {
 		return ConfirmResult{Linked: true}, nil
 	}
-	return s.confirmOrAutoMerge(ctx, callerID, owner)
+	return ConfirmResult{MergeRequired: true, SecondaryID: owner}, nil
 }
 
 // MergeTelegram merges the account owning a gateway-validated Telegram identity
@@ -176,7 +150,7 @@ func (s *Service) ConfirmVK(ctx context.Context, callerID uuid.UUID, externalID
 	if owner == callerID {
 		return ConfirmResult{Linked: true}, nil
 	}
-	return s.confirmOrAutoMerge(ctx, callerID, owner)
+	return ConfirmResult{MergeRequired: true, SecondaryID: owner}, nil
 }
 
 // MergeVK merges the account owning a gateway-validated VK identity into the caller's

backend/internal/payments/availability.go

@@ -1,107 +0,0 @@
-package payments
-
-import "slices"
-
-// PurchaseOverride is a per-account purchase override that forces purchases allowed or denied for
-// one account regardless of the operational rail switch, or is absent (OverrideDefault) when the
-// account follows the rail switch. The zero value is OverrideDefault, so a missing override row maps
-// to it. OverrideAllow bypasses ONLY the operational rail switch — never the security / compliance
-// gates (trusted platform, the D36 email anchor, the VK-iOS spend freeze, the min client version),
-// which CreateOrder enforces separately.
-type PurchaseOverride int
-
-const (
-	// OverrideDefault follows the rail switch (no override row for the account).
-	OverrideDefault PurchaseOverride = iota
-	// OverrideAllow always allows the purchase, bypassing only the operational rail switch.
-	OverrideAllow
-	// OverrideDeny always denies the purchase for the account.
-	OverrideDeny
-)
-
-// RailAvailability is a payment rail's operational availability: whether purchases are enabled and,
-// when disabled, the operator's explanation in each language, shown to the user on a purchase
-// attempt. A rail with no status row is treated as enabled (fail-open — see the store), so the
-// zero value is never used as a live "enabled" default.
-type RailAvailability struct {
-	Enabled   bool
-	MessageRU string
-	MessageEN string
-}
-
-// PurchaseGate decides whether an account may open a purchase order on a rail, from the per-account
-// override and the rail's operational availability. It is the operational layer only — the caller
-// still enforces the security gates. On a block it returns a reason localized to lang ("ru", else
-// English). Fail-open: OverrideDefault on an enabled rail allows.
-func PurchaseGate(override PurchaseOverride, rail RailAvailability, lang string) (ok bool, reason string) {
-	switch override {
-	case OverrideAllow:
-		return true, "" // bypasses only the ops switch; the security gates still apply upstream
-	case OverrideDeny:
-		return false, defaultUnavailable(lang) // a per-account block — a neutral reason
-	default: // OverrideDefault — follow the rail switch
-		if rail.Enabled {
-			return true, ""
-		}
-		return false, railMessage(rail, lang)
-	}
-}
-
-// railMessage returns the operator's rail-off message in lang, falling back to the other language
-// and then to the built-in default when the operator left both blank.
-func railMessage(rail RailAvailability, lang string) string {
-	if lang == "ru" {
-		if rail.MessageRU != "" {
-			return rail.MessageRU
-		}
-		if rail.MessageEN != "" {
-			return rail.MessageEN
-		}
-	} else {
-		if rail.MessageEN != "" {
-			return rail.MessageEN
-		}
-		if rail.MessageRU != "" {
-			return rail.MessageRU
-		}
-	}
-	return defaultUnavailable(lang)
-}
-
-// defaultUnavailable is the built-in localized "payments unavailable" reason used when the operator
-// set no custom message, and for a per-account deny.
-func defaultUnavailable(lang string) string {
-	if lang == "ru" {
-		return "Оплата временно недоступна. Попробуйте позже."
-	}
-	return "Payments are temporarily unavailable. Please try again later."
-}
-
-// Rail keys name the operational payment rails the kill switch and the per-account override key on.
-// The direct rail is split per channel (D42); vk and telegram are single-rail.
-const (
-	RailDirectWeb     = "direct:web"
-	RailDirectAndroid = "direct:android"
-	RailVK            = "vk"
-	RailTelegram      = "telegram"
-)
-
-// KnownRails is the fixed set of rail keys, for the admin editor and for validation.
-var KnownRails = []string{RailDirectWeb, RailDirectAndroid, RailVK, RailTelegram}
-
-// RailKey maps a payment context to its operational rail key: the direct rail by channel subtype
-// (android, else web), or the store rail's own name (vk / telegram).
-func RailKey(kind Source, subtype string) string {
-	if kind == SourceDirect {
-		if subtype == "android" {
-			return RailDirectAndroid
-		}
-		return RailDirectWeb
-	}
-	return string(kind)
-}
-
-// isKnownRail reports whether rail is one of the fixed rail keys.
-func isKnownRail(rail string) bool {
-	return slices.Contains(KnownRails, rail)
-}

backend/internal/payments/availability_test.go

@@ -1,40 +0,0 @@
-package payments
-
-import "testing"
-
-func TestPurchaseGate(t *testing.T) {
-	on := RailAvailability{Enabled: true}
-	offMsg := RailAvailability{Enabled: false, MessageRU: "Чиним", MessageEN: "Fixing"}
-	offNoMsg := RailAvailability{Enabled: false}
-
-	// OverrideDefault follows the rail switch.
-	if ok, _ := PurchaseGate(OverrideDefault, on, "en"); !ok {
-		t.Error("default + enabled rail should allow")
-	}
-	if ok, r := PurchaseGate(OverrideDefault, offMsg, "ru"); ok || r != "Чиним" {
-		t.Errorf("default + off rail (ru) = %v/%q, want false/Чиним", ok, r)
-	}
-	if ok, r := PurchaseGate(OverrideDefault, offMsg, "en"); ok || r != "Fixing" {
-		t.Errorf("default + off rail (en) = %v/%q, want false/Fixing", ok, r)
-	}
-
-	// Off rail with no custom message → the built-in default, localized (not the English default in ru).
-	if ok, r := PurchaseGate(OverrideDefault, offNoMsg, "ru"); ok || r != defaultUnavailable("ru") {
-		t.Errorf("default + off no-msg (ru) = %v/%q, want false + the ru default", ok, r)
-	}
-
-	// OverrideAllow bypasses the ops switch even when the rail is off.
-	if ok, r := PurchaseGate(OverrideAllow, offMsg, "en"); !ok || r != "" {
-		t.Errorf("allow + off rail = %v/%q, want true/empty (bypasses the ops switch)", ok, r)
-	}
-
-	// OverrideDeny blocks even when the rail is on, with a non-empty reason.
-	if ok, r := PurchaseGate(OverrideDeny, on, "en"); ok || r == "" {
-		t.Errorf("deny + on rail = %v/%q, want false + a reason", ok, r)
-	}
-
-	// The message falls back to the other language when only one is set.
-	if _, r := PurchaseGate(OverrideDefault, RailAvailability{MessageEN: "OnlyEN"}, "ru"); r != "OnlyEN" {
-		t.Errorf("off rail ru with only EN msg = %q, want OnlyEN (fallback)", r)
-	}
-}

backend/internal/payments/catalog.go

@@ -38,11 +38,6 @@ const atomChips = "chips"
 // method are omitted (misconfigured or unavailable there). An untrusted context (empty Kind) has
 // no method, so only values show; buying is gated server-side regardless.
 func projectCatalog(entries []catalogEntry, cxt Context) CatalogView {
-	// Present products in the canonical listing order shared with the offer and the admin console
-	// (packs first by rouble price, then values grouped hints → no-ads → combo and by chip price); the
-	// client renders them as received. Ordered in place — the caller passes a fresh loadCatalog result
-	// it does not reuse.
-	sortCatalogEntries(entries)
 	var out CatalogView
 	for _, e := range entries {
 		isPack := false

backend/internal/payments/catalog_admin.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math"
-	"slices"
 	"strings"
 
 	"github.com/google/uuid"
@@ -143,60 +141,10 @@ func validateProduct(in ProductInput, sellable bool) error {
 	return nil
 }
 
-// AdminCatalog lists products with their composition, prices and whether each has been transacted,
+// AdminCatalog lists every product (active and archived) with its composition, prices and whether it
-// for the admin editor. includeInactive adds the archived products to the active ones (the console's
+// has been transacted, for the admin editor. Read uncached, straight from the catalog tables.
-// active/all toggle); with it false only active products are returned. Read uncached, straight from
+func (s *Service) AdminCatalog(ctx context.Context) ([]AdminProduct, error) {
-// the catalog tables.
+	return s.store.adminCatalog(ctx)
-func (s *Service) AdminCatalog(ctx context.Context, includeInactive bool) ([]AdminProduct, error) {
-	return s.store.adminCatalog(ctx, includeInactive)
-}
-
-// SortAdminCatalog orders an admin catalog list in place the same way the public offer lists products
-// ([projectOfferPricing]): chip packs first, ascending by rouble price; then chip-priced values,
-// grouped (hints only, no-ads only, no-ads + hints, tournament) and ascending by chip price within a
-// group. It is stable, so equal-keyed products keep their incoming order, and it keys archived
-// products the same as active ones (the admin list shows both).
-func SortAdminCatalog(products []AdminProduct) {
-	slices.SortStableFunc(products, func(a, b AdminProduct) int {
-		return compareCatalogRank(adminRank(a), adminRank(b))
-	})
-}
-
-// adminIsPack reports whether the product is a chip pack (it carries the chips atom).
-func adminIsPack(p AdminProduct) bool {
-	for _, a := range p.Atoms {
-		if a.Atom == atomChips {
-			return true
-		}
-	}
-	return false
-}
-
-// adminValueGroup ranks a chip-priced value into the shared listing groups (see [valueGroup]).
-func adminValueGroup(p AdminProduct) int {
-	hasHints, hasNoAds, hasTournament := false, false, false
-	for _, a := range p.Atoms {
-		switch a.Atom {
-		case "hints":
-			hasHints = true
-		case "noads_days":
-			hasNoAds = true
-		case "tournament":
-			hasTournament = true
-		}
-	}
-	return valueGroup(hasHints, hasNoAds, hasTournament)
-}
-
-// adminPriceAmount returns the minor-unit amount of the product's price for the method and currency,
-// or math.MaxInt64 when it carries no such price (so a misconfigured product sorts last, not first).
-func adminPriceAmount(p AdminProduct, method string, cur Currency) int64 {
-	for _, pr := range p.Prices {
-		if pr.Method == method && pr.Currency == cur {
-			return pr.Amount
-		}
-	}
-	return math.MaxInt64
 }
 
 // CreateProduct validates and inserts a new product with its atoms and prices, returning its id. A
@@ -205,11 +153,7 @@ func (s *Service) CreateProduct(ctx context.Context, in ProductInput, active boo
 	if err := validateProduct(in, active); err != nil {
 		return uuid.Nil, err
 	}
-	id, err := s.store.createProduct(ctx, in, active, s.clock())
+	return s.store.createProduct(ctx, in, active, s.clock())
-	if err == nil {
-		s.markOfferStale()
-	}
-	return id, err
 }
 
 // UpdateProduct validates and replaces a product's title, atoms and prices. An active product must
@@ -222,11 +166,7 @@ func (s *Service) UpdateProduct(ctx context.Context, id uuid.UUID, in ProductInp
 	if err := validateProduct(in, active); err != nil {
 		return err
 	}
-	if err := s.store.updateProduct(ctx, id, in, s.clock()); err != nil {
+	return s.store.updateProduct(ctx, id, in, s.clock())
-		return err
-	}
-	s.markOfferStale()
-	return nil
 }
 
 // SetProductActive archives (active=false) or unarchives a product. Unarchiving revalidates the
@@ -241,19 +181,11 @@ func (s *Service) SetProductActive(ctx context.Context, id uuid.UUID, active boo
 			return err
 		}
 	}
-	if err := s.store.setProductActive(ctx, id, active, s.clock()); err != nil {
+	return s.store.setProductActive(ctx, id, active, s.clock())
-		return err
-	}
-	s.markOfferStale()
-	return nil
 }
 
 // DeleteProduct hard-deletes a product only when it has never been transacted (no order or ledger
 // row references it); otherwise it returns ErrProductTransacted and the caller archives instead.
 func (s *Service) DeleteProduct(ctx context.Context, id uuid.UUID) error {
-	if err := s.store.deleteProduct(ctx, id); err != nil {
+	return s.store.deleteProduct(ctx, id)
-		return err
-	}
-	s.markOfferStale()
-	return nil
 }

backend/internal/payments/catalog_order.go

@@ -1,61 +0,0 @@
-package payments
-
-import (
-	"cmp"
-	"slices"
-)
-
-// catalogRank is the canonical listing key for a catalog product: whether it is a chip pack, its
-// value subgroup (see [valueGroup]; unused for a pack) and the minor-unit amount its section sorts by
-// (a pack's direct rouble price, a value's chip price; math.MaxInt64 when absent, so a misconfigured
-// row sorts last rather than leading).
-type catalogRank struct {
-	pack   bool
-	group  int
-	amount int64
-}
-
-// compareCatalogRank is the single canonical product order, shared by the storefront ([projectCatalog]),
-// the public offer ([projectOfferPricing]) and the admin catalog ([SortAdminCatalog]): chip packs
-// first, ascending by rouble price; then chip-priced values grouped hints → no-ads → combo →
-// tournament and, within a group, ascending by chip price. A pack's group is unused (all packs share
-// one section). Callers use it through [entryRank] / [adminRank], which build the key from each
-// product shape, so the subgroup and ordering rules live in exactly one place.
-func compareCatalogRank(a, b catalogRank) int {
-	if a.pack != b.pack {
-		if a.pack {
-			return -1 // packs (sales) before values (chip exchange)
-		}
-		return 1
-	}
-	if !a.pack {
-		if d := cmp.Compare(a.group, b.group); d != 0 {
-			return d
-		}
-	}
-	return cmp.Compare(a.amount, b.amount)
-}
-
-// entryRank builds the canonical rank of a storefront / offer catalog entry.
-func entryRank(e catalogEntry) catalogRank {
-	if isPackEntry(e) {
-		return catalogRank{pack: true, amount: offerSortAmount(e, string(SourceDirect), CurrencyRUB)}
-	}
-	return catalogRank{group: offerValueGroup(e), amount: offerSortAmount(e, "", CurrencyChip)}
-}
-
-// adminRank builds the canonical rank of an admin catalog product.
-func adminRank(p AdminProduct) catalogRank {
-	if adminIsPack(p) {
-		return catalogRank{pack: true, amount: adminPriceAmount(p, string(SourceDirect), CurrencyRUB)}
-	}
-	return catalogRank{group: adminValueGroup(p), amount: adminPriceAmount(p, "", CurrencyChip)}
-}
-
-// sortCatalogEntries orders storefront / offer entries in place into the canonical listing order
-// ([compareCatalogRank]). Stable, so equal-keyed products keep their incoming (creation) order.
-func sortCatalogEntries(entries []catalogEntry) {
-	slices.SortStableFunc(entries, func(a, b catalogEntry) int {
-		return compareCatalogRank(entryRank(a), entryRank(b))
-	})
-}

backend/internal/payments/catalog_test.go

@@ -134,97 +134,3 @@ func TestProjectCatalog_Empty(t *testing.T) {
 		t.Errorf("empty catalog projected %d products, want 0", len(got.Products))
 	}
 }
-
-// TestProjectCatalog_CanonicalOrder checks the storefront lists products in the shared canonical order
-// (compareCatalogRank): chip packs first ascending by rouble price, then chip-priced values grouped
-// hints → no-ads → combo and ascending by chip price — the same order as the offer and the admin
-// console, regardless of catalog creation order.
-func TestProjectCatalog_CanonicalOrder(t *testing.T) {
-	pack := func(title string, rub int64) catalogEntry {
-		return catalogEntry{
-			id:     uuid.New(),
-			title:  title,
-			atoms:  []atomQty{{atomType: atomChips, quantity: 1}},
-			prices: []priceRow{{method: "direct", currency: CurrencyRUB, amount: rub}},
-		}
-	}
-	value := func(title string, chips int64, atoms ...string) catalogEntry {
-		e := catalogEntry{id: uuid.New(), title: title, prices: []priceRow{{method: "", currency: CurrencyChip, amount: chips}}}
-		for _, a := range atoms {
-			e.atoms = append(e.atoms, atomQty{atomType: a, quantity: 1})
-		}
-		return e
-	}
-	// Deliberately shuffled on input; the projection must impose the canonical order.
-	entries := []catalogEntry{
-		pack("packDear", 30000),
-		value("bundle", 500, "hints", "noads_days"),
-		pack("packCheap", 10000),
-		value("adsOnly", 150, "noads_days"),
-		value("hintsBig", 200, "hints"),
-		value("hintsSmall", 50, "hints"),
-	}
-	got := projectCatalog(entries, Context{Kind: SourceDirect})
-	want := []string{"packCheap", "packDear", "hintsSmall", "hintsBig", "adsOnly", "bundle"}
-	if len(got.Products) != len(want) {
-		t.Fatalf("projected %d products, want %d", len(got.Products), len(want))
-	}
-	for i, p := range got.Products {
-		if p.Title != want[i] {
-			t.Fatalf("order[%d] = %q, want %q (full: %v)", i, p.Title, want[i], productTitles(got.Products))
-		}
-	}
-}
-
-// productTitles extracts the projected product titles for a failure message.
-func productTitles(products []CatalogProduct) []string {
-	out := make([]string, len(products))
-	for i, p := range products {
-		out[i] = p.Title
-	}
-	return out
-}
-
-// TestSortAdminCatalog checks the admin list is ordered like the public offer: chip packs first,
-// ascending by rouble price; then values, grouped (hints only -> no-ads only -> no-ads + hints) and
-// ascending by chip price within a group. Stable and applied to active + archived alike.
-func TestSortAdminCatalog(t *testing.T) {
-	pack := func(title string, rub int64) AdminProduct {
-		return AdminProduct{
-			Title:  title,
-			Atoms:  []AtomLine{{Atom: atomChips, Quantity: 1}},
-			Prices: []PriceLine{{Method: string(SourceDirect), Currency: CurrencyRUB, Amount: rub}},
-		}
-	}
-	value := func(title string, chips int64, atoms ...string) AdminProduct {
-		p := AdminProduct{Title: title, Prices: []PriceLine{{Currency: CurrencyChip, Amount: chips}}}
-		for _, a := range atoms {
-			p.Atoms = append(p.Atoms, AtomLine{Atom: a, Quantity: 1})
-		}
-		return p
-	}
-	products := []AdminProduct{
-		pack("packDear", 30000),
-		value("bundle", 500, "hints", "noads_days"),
-		pack("packCheap", 10000),
-		value("adsOnly", 150, "noads_days"),
-		value("hintsBig", 200, "hints"),
-		value("hintsSmall", 50, "hints"),
-	}
-	SortAdminCatalog(products)
-	want := []string{"packCheap", "packDear", "hintsSmall", "hintsBig", "adsOnly", "bundle"}
-	for i, p := range products {
-		if p.Title != want[i] {
-			t.Fatalf("order[%d] = %q, want %q (full: %v)", i, p.Title, want[i], titles(products))
-		}
-	}
-}
-
-// titles extracts the product titles for a failure message.
-func titles(products []AdminProduct) []string {
-	out := make([]string, len(products))
-	for i, p := range products {
-		out[i] = p.Title
-	}
-	return out
-}

backend/internal/payments/offer.go

@@ -1,210 +0,0 @@
-package payments
-
-import (
-	"context"
-	"fmt"
-	"math"
-	"slices"
-	"strings"
-)
-
-// pricingMarker is the token the owner-edited offer markdown (ui/legal/offer_ru.md, §4.4) carries
-// where the price list belongs. The render sidecar replaces it with the markdown [Service.OfferPricing]
-// returns before rendering the /offer/ page; the backend only produces the tables, never the marker.
-const pricingMarker = "<#pricing_template#>"
-
-// OfferPricing returns the public-offer price list (§4.4) as two markdown tables projected from the
-// active catalog: first the chip packs (funding chips with money, priced per rail — roubles / VK
-// votes / Telegram Stars), then the chip-priced values (what a player exchanges chips for). The
-// result is cached in memory and reprojected only after a catalog mutation (see [Service.markOfferStale]),
-// so a steady-state read issues no query — only the first read after an edit reprojects. The render
-// sidecar fetches it and splices it into the offer markdown at the pricing marker.
-func (s *Service) OfferPricing(ctx context.Context) (string, error) {
-	s.offerMu.Lock()
-	defer s.offerMu.Unlock()
-	if s.offerFresh {
-		return s.offerMD, nil
-	}
-	md, err := s.buildOfferPricing(ctx)
-	if err != nil {
-		return "", err
-	}
-	s.offerMD = md
-	s.offerFresh = true
-	return md, nil
-}
-
-// markOfferStale marks the cached offer price list for reprojection on the next [Service.OfferPricing]
-// read. Every catalog mutation calls it; it takes no I/O, so it never fails the mutation that triggers it.
-func (s *Service) markOfferStale() {
-	s.offerMu.Lock()
-	s.offerFresh = false
-	s.offerMu.Unlock()
-}
-
-// buildOfferPricing loads the active catalog and projects it into the offer tables.
-func (s *Service) buildOfferPricing(ctx context.Context) (string, error) {
-	entries, err := s.store.loadCatalog(ctx)
-	if err != nil {
-		return "", err
-	}
-	return projectOfferPricing(entries), nil
-}
-
-// projectOfferPricing renders the active catalog into the two offer tables. A chip pack (it carries
-// the chips atom) lists its per-rail money price; a value (no chips atom) lists its uniform chip
-// price. Packs are ordered by ascending rouble price; values are grouped by what they grant (hints
-// only, then no-ads only, then no-ads + hints, then tournament — see [offerValueGroup]) and, within
-// each group, ordered by ascending chip price. Price columns are right-aligned. An empty section is
-// omitted. Amounts are rendered through [Money] so no floating point ever reaches the page (roubles
-// show kopecks as "200.00", whole-unit rails as integers); a missing rail price shows an em dash.
-func projectOfferPricing(entries []catalogEntry) string {
-	// Order the whole catalog once by the shared canonical rank, then split it into the two offer
-	// tables (packs first, then the chip-exchange values); each keeps that order. Sort a copy so the
-	// caller's slice is left untouched.
-	sorted := slices.Clone(entries)
-	sortCatalogEntries(sorted)
-	var packs, values []catalogEntry
-	for _, e := range sorted {
-		if isPackEntry(e) {
-			packs = append(packs, e)
-		} else {
-			values = append(values, e)
-		}
-	}
-
-	var b strings.Builder
-	if len(packs) > 0 {
-		b.WriteString("Приобретение внутриигровой валюты «Фишка»:\n\n")
-		b.WriteString("| Наименование | Рубли | Голоса в VK | Stars в Telegram |\n")
-		b.WriteString("| --- | ---: | ---: | ---: |\n")
-		for _, e := range packs {
-			fmt.Fprintf(&b, "| %s | %s | %s | %s |\n",
-				offerCell(e.title),
-				offerPrice(e, string(SourceDirect), CurrencyRUB),
-				offerPrice(e, string(SourceVK), CurrencyVote),
-				offerPrice(e, string(SourceTelegram), CurrencyStar),
-			)
-		}
-	}
-	if len(values) > 0 {
-		if len(packs) > 0 {
-			b.WriteString("\n")
-		}
-		b.WriteString("Использование внутриигровой валюты «Фишка»:\n\n")
-		b.WriteString("| Наименование | «Фишки» |\n")
-		b.WriteString("| --- | ---: |\n")
-		for _, e := range values {
-			fmt.Fprintf(&b, "| %s | %s |\n", offerCell(e.title), offerPrice(e, "", CurrencyChip))
-		}
-	}
-	return strings.TrimRight(b.String(), "\n")
-}
-
-// offerValueGroup ranks a chip-priced value into the usage groups (see [valueGroup]).
-func offerValueGroup(e catalogEntry) int {
-	hasHints, hasNoAds, hasTournament := false, false, false
-	for _, a := range e.atoms {
-		switch a.atomType {
-		case "hints":
-			hasHints = true
-		case "noads_days":
-			hasNoAds = true
-		case "tournament":
-			hasTournament = true
-		}
-	}
-	return valueGroup(hasHints, hasNoAds, hasTournament)
-}
-
-// valueGroup ranks a chip-priced value into the listing groups shared by the public offer and the
-// admin catalog, in listing order: hints only (0), no-ads only (1), no-ads + hints (2), then anything
-// carrying the tournament atom (3). Tournament products are not sellable yet (validateProduct forbids
-// an active one), so group 3 is empty today; the rank reserves their place for when the tournament
-// economy lands. A value with no recognised benefit atom sorts after the known groups (defensive —
-// the catalog shape forbids it).
-func valueGroup(hasHints, hasNoAds, hasTournament bool) int {
-	switch {
-	case hasTournament:
-		return 3
-	case hasHints && hasNoAds:
-		return 2
-	case hasNoAds:
-		return 1
-	case hasHints:
-		return 0
-	default:
-		return 4
-	}
-}
-
-// offerSortAmount returns the entry's price in the given method and currency for ordering, or
-// math.MaxInt64 when it carries no such price, so a misconfigured row sorts last rather than leading.
-func offerSortAmount(e catalogEntry, method string, cur Currency) int64 {
-	if amt, ok := offerAmount(e, method, cur); ok {
-		return amt
-	}
-	return math.MaxInt64
-}
-
-// isPackEntry reports whether the catalog entry is a chip pack — it carries the chips atom (funds
-// chips with money) rather than being a chip-priced value.
-func isPackEntry(e catalogEntry) bool {
-	for _, a := range e.atoms {
-		if a.atomType == atomChips {
-			return true
-		}
-	}
-	return false
-}
-
-// offerPrice formats the entry's price for the given payment method and currency as a major-unit
-// string, or an em dash when the entry carries no such price.
-func offerPrice(e catalogEntry, method string, cur Currency) string {
-	amt, ok := offerAmount(e, method, cur)
-	if !ok {
-		return "—"
-	}
-	m, err := MoneyFromMinor(amt, cur)
-	if err != nil {
-		return "—"
-	}
-	return m.Major()
-}
-
-// offerAmount returns the raw minor-unit amount of the entry's price for the payment method and
-// currency, and whether such a price exists.
-func offerAmount(e catalogEntry, method string, cur Currency) (int64, bool) {
-	for _, pr := range e.prices {
-		if pr.method == method && pr.currency == cur {
-			return pr.amount, true
-		}
-	}
-	return 0, false
-}
-
-// offerCellReplacer neutralises every metacharacter of an admin-entered title so it renders as
-// literal text in the public offer. The title is operator input (the /_gm catalog editor) that flows
-// into a markdown table cell and then through marked into the /offer/ HTML, which is deliberately not
-// sanitised — so escaping here is the trust boundary. It covers HTML (no tag or entity reaches the
-// page), the markdown table pipe and the row newline, and the link brackets (a title must never
-// become a "javascript:" link). marked passes the entities through unchanged, so the reader sees the
-// exact title. NewReplacer scans once and never re-scans its own output, so "&" → "&amp;" does not
-// double-escape the entities the other rules emit.
-var offerCellReplacer = strings.NewReplacer(
-	"&", "&amp;",
-	"<", "&lt;",
-	">", "&gt;",
-	`"`, "&quot;",
-	"'", "&#39;",
-	"|", `\|`,
-	"[", `\[`,
-	"]", `\]`,
-	"\n", " ",
-)
-
-// offerCell escapes an admin-entered title for safe, literal rendering in a markdown table cell of
-// the public offer (see [offerCellReplacer]).
-func offerCell(s string) string {
-	return offerCellReplacer.Replace(s)
-}

backend/internal/payments/offer_test.go

@@ -1,137 +0,0 @@
-package payments
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/google/uuid"
-)
-
-// TestProjectOfferPricing checks the happy path: a chip pack priced on every rail and a chip-priced
-// value render into the two tables, pack table first, money formatted through Money.
-func TestProjectOfferPricing(t *testing.T) {
-	entries := []catalogEntry{
-		{
-			id:    uuid.New(),
-			title: "50 «Фишек»",
-			atoms: []atomQty{{atomType: atomChips, quantity: 50}},
-			prices: []priceRow{
-				{method: string(SourceDirect), currency: CurrencyRUB, amount: 20000},
-				{method: string(SourceVK), currency: CurrencyVote, amount: 30},
-				{method: string(SourceTelegram), currency: CurrencyStar, amount: 100},
-			},
-		},
-		{
-			id:     uuid.New(),
-			title:  "200 подсказок",
-			atoms:  []atomQty{{atomType: "hints", quantity: 200}},
-			prices: []priceRow{{method: "", currency: CurrencyChip, amount: 50}},
-		},
-	}
-	md := projectOfferPricing(entries)
-	for _, want := range []string{
-		"| Наименование | Рубли | Голоса в VK | Stars в Telegram |",
-		"| --- | ---: | ---: | ---: |", // price columns right-aligned
-		"| 50 «Фишек» | 200.00 | 30 | 100 |",
-		"| Наименование | «Фишки» |",
-		"| --- | ---: |",
-		"| 200 подсказок | 50 |",
-	} {
-		if !strings.Contains(md, want) {
-			t.Errorf("projection missing %q\n---\n%s", want, md)
-		}
-	}
-	if strings.Index(md, "Приобретение") > strings.Index(md, "Использование") {
-		t.Errorf("the pack table must precede the values table:\n%s", md)
-	}
-}
-
-// TestProjectOfferPricingOrdering checks packs sort by ascending rouble price, and values sort by
-// group (hints only → no-ads only → no-ads + hints) then ascending chip price within a group.
-func TestProjectOfferPricingOrdering(t *testing.T) {
-	pack := func(title string, rub int64) catalogEntry {
-		return catalogEntry{
-			id:     uuid.New(),
-			title:  title,
-			atoms:  []atomQty{{atomType: atomChips, quantity: 1}},
-			prices: []priceRow{{method: string(SourceDirect), currency: CurrencyRUB, amount: rub}},
-		}
-	}
-	value := func(title string, chips int64, atoms ...string) catalogEntry {
-		e := catalogEntry{id: uuid.New(), title: title, prices: []priceRow{{method: "", currency: CurrencyChip, amount: chips}}}
-		for _, a := range atoms {
-			e.atoms = append(e.atoms, atomQty{atomType: a, quantity: 1})
-		}
-		return e
-	}
-	// Deliberately out of order on input.
-	entries := []catalogEntry{
-		pack("packDear", 30000),
-		pack("packCheap", 10000),
-		value("bundle", 500, "hints", "noads_days"),
-		value("adsOnly", 150, "noads_days"),
-		value("hintsBig", 200, "hints"),
-		value("hintsSmall", 50, "hints"),
-	}
-	md := projectOfferPricing(entries)
-	order := []string{"packCheap", "packDear", "hintsSmall", "hintsBig", "adsOnly", "bundle"}
-	last := -1
-	for _, title := range order {
-		i := strings.Index(md, "| "+title+" |")
-		if i < 0 {
-			t.Fatalf("row %q missing:\n%s", title, md)
-		}
-		if i < last {
-			t.Errorf("row %q out of order (want sequence %v):\n%s", title, order, md)
-		}
-		last = i
-	}
-}
-
-// TestProjectOfferPricingMissingRailAndEscaping checks a pack missing a rail shows an em dash and a
-// title carrying a pipe is escaped so the table layout survives.
-func TestProjectOfferPricingMissingRailAndEscaping(t *testing.T) {
-	entries := []catalogEntry{{
-		id:    uuid.New(),
-		title: "Bonus | pack",
-		atoms: []atomQty{{atomType: atomChips, quantity: 10}},
-		// A roubles price only — no VK, no Telegram.
-		prices: []priceRow{{method: string(SourceDirect), currency: CurrencyRUB, amount: 9900}},
-	}}
-	md := projectOfferPricing(entries)
-	if want := `| Bonus \| pack | 99.00 | — | — |`; !strings.Contains(md, want) {
-		t.Errorf("want row %q in:\n%s", want, md)
-	}
-}
-
-// TestProjectOfferPricingEscapesHTMLAndLinks checks an admin title carrying HTML or a markdown link
-// is neutralised so it cannot inject markup into the public offer: the tag becomes entities and the
-// link brackets are escaped (so no "javascript:" anchor forms). The raw metacharacters must not
-// survive into the projected markdown.
-func TestProjectOfferPricingEscapesHTMLAndLinks(t *testing.T) {
-	entries := []catalogEntry{{
-		id:     uuid.New(),
-		title:  `<script>alert(1)</script> [x](javascript:alert(2)) & "q"`,
-		atoms:  []atomQty{{atomType: "hints", quantity: 1}},
-		prices: []priceRow{{method: "", currency: CurrencyChip, amount: 5}},
-	}}
-	md := projectOfferPricing(entries)
-	for _, bad := range []string{"<script>", "</script>", "[x]", `& "q"`} {
-		if strings.Contains(md, bad) {
-			t.Errorf("unescaped %q survived into the projection:\n%s", bad, md)
-		}
-	}
-	for _, want := range []string{"&lt;script&gt;", `\[x\]`, "&amp;", "&quot;q&quot;"} {
-		if !strings.Contains(md, want) {
-			t.Errorf("want escaped %q in:\n%s", want, md)
-		}
-	}
-}
-
-// TestProjectOfferPricingEmpty checks an empty catalog projects to the empty string (no stray table
-// headers), so the offer's pricing marker is replaced with nothing.
-func TestProjectOfferPricingEmpty(t *testing.T) {
-	if got := projectOfferPricing(nil); got != "" {
-		t.Errorf("empty catalog must project to empty string, got %q", got)
-	}
-}

backend/internal/payments/service.go

@@ -5,7 +5,6 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
-	"sync"
 	"time"
 
 	"github.com/google/uuid"
@@ -20,13 +19,6 @@ import (
 type Service struct {
 	store *Store
 	clock func() time.Time
-
-	// offerMu guards the cached public-offer price list (§4.4). offerMD holds the projected
-	// markdown tables and offerFresh whether they are current; a catalog mutation clears offerFresh
-	// (markOfferStale) and the next OfferPricing read reprojects, so a served render issues no query.
-	offerMu    sync.Mutex
-	offerMD    string
-	offerFresh bool
 }
 
 // NewService constructs a Service over store with a wall-clock time source.

backend/internal/payments/service_availability.go

@@ -1,63 +0,0 @@
-package payments
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/google/uuid"
-)
-
-// CanPurchase reports whether an account may open a purchase order on rail, combining the account's
-// per-account override with the rail's operational switch (PurchaseGate). It is the operational
-// availability layer only — the caller still enforces the security gates (trusted platform, the D36
-// email anchor, the VK-iOS spend freeze, the min client version). On a block, reason is localized to
-// lang for the user; err is only a store failure.
-func (s *Service) CanPurchase(ctx context.Context, accountID uuid.UUID, rail, lang string) (ok bool, reason string, err error) {
-	ov, err := s.store.purchaseOverride(ctx, accountID)
-	if err != nil {
-		return false, "", err
-	}
-	avail, err := s.store.railAvailability(ctx, rail)
-	if err != nil {
-		return false, "", err
-	}
-	ok, reason = PurchaseGate(ov, avail, lang)
-	return ok, reason, nil
-}
-
-// RailStatuses returns every known rail's operational status for the admin editor, filling a rail
-// with no stored row with the fail-open enabled default so the editor always shows one row per rail.
-func (s *Service) RailStatuses(ctx context.Context) (map[string]RailAvailability, error) {
-	stored, err := s.store.allRailStatus(ctx)
-	if err != nil {
-		return nil, err
-	}
-	out := make(map[string]RailAvailability, len(KnownRails))
-	for _, rail := range KnownRails {
-		if a, ok := stored[rail]; ok {
-			out[rail] = a
-		} else {
-			out[rail] = RailAvailability{Enabled: true}
-		}
-	}
-	return out, nil
-}
-
-// SetRailStatus upserts a rail's operational status from the admin editor. It rejects an unknown rail
-// key so a typo cannot create a dead row.
-func (s *Service) SetRailStatus(ctx context.Context, rail string, a RailAvailability) error {
-	if !isKnownRail(rail) {
-		return fmt.Errorf("payments: unknown rail %q", rail)
-	}
-	return s.store.setRailStatus(ctx, rail, a, s.clock())
-}
-
-// PurchaseOverrideFor returns an account's purchase override (OverrideDefault when none is set).
-func (s *Service) PurchaseOverrideFor(ctx context.Context, accountID uuid.UUID) (PurchaseOverride, error) {
-	return s.store.purchaseOverride(ctx, accountID)
-}
-
-// SetPurchaseOverride sets or clears an account's purchase override (OverrideDefault deletes the row).
-func (s *Service) SetPurchaseOverride(ctx context.Context, accountID uuid.UUID, ov PurchaseOverride) error {
-	return s.store.setPurchaseOverride(ctx, accountID, ov, s.clock())
-}

backend/internal/payments/service_intake.go

@@ -46,7 +46,6 @@ func (s *Service) CreateOrder(ctx context.Context, accountID uuid.UUID, cxt Cont
 		amount:    pack.price,
 		origin:    method,
 		provider:  provider,
-		shop:      directShop(cxt),
 	}
 	if err := s.store.createOrder(ctx, o, s.clock()); err != nil {
 		return OrderResult{}, err
@@ -54,16 +53,6 @@ func (s *Service) CreateOrder(ctx context.Context, accountID uuid.UUID, cxt Cont
 	return OrderResult{OrderID: orderID, Amount: pack.price, Title: pack.title}, nil
 }
 
-// directShop returns the merchant shop (channel) a direct order is issued through — the trusted
-// platform subtype for the direct rail ("web"/"android"), or "" for any other rail (the per-shop
-// split is direct-only; D42/D44). Recorded on the order for the admin per-channel breakdown.
-func directShop(cxt Context) string {
-	if cxt.Kind == SourceDirect {
-		return cxt.Subtype
-	}
-	return ""
-}
-
 // OrderItem returns a pending order's human title and the amount it charges, in the order's own
 // currency — the details a provider's item-lookup phase needs (VK's get_item). It reads the order
 // and the pack title, honouring the pack even if it was later deactivated (mirrors Fund).
@@ -168,22 +157,6 @@ func (s *Service) RewardPayout(ctx context.Context, cxt Context, present []Sourc
 	return payout, err
 }
 
-// RewardConfig reads the rewarded-video config for the admin editor: the payout (chips per view) and
-// the per-day and per-hour caps.
-func (s *Service) RewardConfig(ctx context.Context) (payout, dailyCap, hourlyCap int, err error) {
-	return s.store.rewardConfig(ctx)
-}
-
-// SetRewardConfig updates the rewarded-video config (the payout and the two caps). All three must be
-// non-negative; a 0 payout leaves rewarded inert. It is not a catalog product, so it does not mark the
-// offer stale.
-func (s *Service) SetRewardConfig(ctx context.Context, payout, dailyCap, hourlyCap int) error {
-	if payout < 0 || dailyCap < 0 || hourlyCap < 0 {
-		return errors.New("payments: reward payout and caps must be non-negative")
-	}
-	return s.store.setRewardConfig(ctx, payout, dailyCap, hourlyCap)
-}
-
 // CreditReward credits a rewarded-video view's chips to the VK segment, client-attested (VK Mini App
 // ads expose no server verify — the client's watch result is trusted for an honest user; a forger who
 // skips the ad and calls the endpoint is bounded by the config daily cap). It is idempotent on the

backend/internal/payments/statement.go

@@ -42,8 +42,7 @@ type RiskInfo struct {
 }
 
 // LedgerEntry is one append-only ledger row projected for the report. The string ids are empty when
-// the column is NULL; Shop is the direct-rail merchant channel the referenced order used (empty for
+// the column is NULL; Snapshot is the raw purchase/refund JSON (empty when none).
-// other rails or order-less rows); Snapshot is the raw purchase/refund JSON (empty when none).
 type LedgerEntry struct {
 	Kind              string
 	Source            string
@@ -53,7 +52,6 @@ type LedgerEntry struct {
 	OrderID           string
 	Provider          string
 	ProviderPaymentID string
-	Shop              string
 	Snapshot          string
 	CreatedAt         time.Time
 }

backend/internal/payments/store_availability.go

@@ -1,96 +0,0 @@
-package payments
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-)
-
-// railAvailability reads a rail's operational availability. A missing row is fail-open: enabled with
-// no message, so payments stay on unless an operator explicitly disabled the rail.
-func (s *Store) railAvailability(ctx context.Context, rail string) (RailAvailability, error) {
-	var a RailAvailability
-	err := s.db.QueryRowContext(ctx,
-		`SELECT enabled, message_ru, message_en FROM payments.rail_status WHERE rail = $1`, rail).
-		Scan(&a.Enabled, &a.MessageRU, &a.MessageEN)
-	if errors.Is(err, sql.ErrNoRows) {
-		return RailAvailability{Enabled: true}, nil
-	}
-	if err != nil {
-		return RailAvailability{}, fmt.Errorf("payments: read rail status %q: %w", rail, err)
-	}
-	return a, nil
-}
-
-// allRailStatus reads every stored rail-status row for the admin editor, keyed by rail. Rails with
-// no row are absent (the caller fills them with the fail-open enabled default).
-func (s *Store) allRailStatus(ctx context.Context) (map[string]RailAvailability, error) {
-	rows, err := s.db.QueryContext(ctx,
-		`SELECT rail, enabled, message_ru, message_en FROM payments.rail_status`)
-	if err != nil {
-		return nil, fmt.Errorf("payments: read rail statuses: %w", err)
-	}
-	defer rows.Close()
-	out := make(map[string]RailAvailability)
-	for rows.Next() {
-		var rail string
-		var a RailAvailability
-		if err := rows.Scan(&rail, &a.Enabled, &a.MessageRU, &a.MessageEN); err != nil {
-			return nil, fmt.Errorf("payments: scan rail status: %w", err)
-		}
-		out[rail] = a
-	}
-	return out, rows.Err()
-}
-
-// setRailStatus upserts a rail's operational status (admin).
-func (s *Store) setRailStatus(ctx context.Context, rail string, a RailAvailability, now time.Time) error {
-	if _, err := s.db.ExecContext(ctx,
-		`INSERT INTO payments.rail_status (rail, enabled, message_ru, message_en, updated_at)
-		 VALUES ($1, $2, $3, $4, $5)
-		 ON CONFLICT (rail) DO UPDATE SET enabled = $2, message_ru = $3, message_en = $4, updated_at = $5`,
-		rail, a.Enabled, a.MessageRU, a.MessageEN, now); err != nil {
-		return fmt.Errorf("payments: set rail status %q: %w", rail, err)
-	}
-	return nil
-}
-
-// purchaseOverride reads an account's purchase override; a missing row is OverrideDefault.
-func (s *Store) purchaseOverride(ctx context.Context, accountID uuid.UUID) (PurchaseOverride, error) {
-	var allow bool
-	err := s.db.QueryRowContext(ctx,
-		`SELECT allow FROM payments.account_payment_override WHERE account_id = $1`, accountID).Scan(&allow)
-	if errors.Is(err, sql.ErrNoRows) {
-		return OverrideDefault, nil
-	}
-	if err != nil {
-		return OverrideDefault, fmt.Errorf("payments: read purchase override %s: %w", accountID, err)
-	}
-	if allow {
-		return OverrideAllow, nil
-	}
-	return OverrideDeny, nil
-}
-
-// setPurchaseOverride upserts an account's override, or deletes the row for OverrideDefault (the
-// default state is the absence of a row).
-func (s *Store) setPurchaseOverride(ctx context.Context, accountID uuid.UUID, ov PurchaseOverride, now time.Time) error {
-	if ov == OverrideDefault {
-		if _, err := s.db.ExecContext(ctx,
-			`DELETE FROM payments.account_payment_override WHERE account_id = $1`, accountID); err != nil {
-			return fmt.Errorf("payments: clear purchase override %s: %w", accountID, err)
-		}
-		return nil
-	}
-	if _, err := s.db.ExecContext(ctx,
-		`INSERT INTO payments.account_payment_override (account_id, allow, updated_at) VALUES ($1, $2, $3)
-		 ON CONFLICT (account_id) DO UPDATE SET allow = $2, updated_at = $3`,
-		accountID, ov == OverrideAllow, now); err != nil {
-		return fmt.Errorf("payments: set purchase override %s: %w", accountID, err)
-	}
-	return nil
-}

backend/internal/payments/store_catalog_admin.go

@@ -19,17 +19,11 @@ import (
 // row references — it must be archived instead, to keep the append-only ledger resolvable.
 var ErrProductTransacted = errors.New("payments: product has transactions; archive instead of delete")
 
-// adminCatalog lists products with their atoms, prices and transacted flag. includeInactive adds the
+// adminCatalog lists every product (active and archived) with its atoms, prices and transacted flag.
-// archived products to the active ones; with it false only active products are returned.
+func (s *Store) adminCatalog(ctx context.Context) ([]AdminProduct, error) {
-func (s *Store) adminCatalog(ctx context.Context, includeInactive bool) ([]AdminProduct, error) {
-	where := table.Product.Active.IS_TRUE()
-	if includeInactive {
-		where = postgres.Bool(true)
-	}
 	var prods []model.Product
 	if err := postgres.SELECT(table.Product.AllColumns).
 		FROM(table.Product).
-		WHERE(where).
 		ORDER_BY(table.Product.CreatedAt.ASC()).
 		QueryContext(ctx, s.db, &prods); err != nil {
 		return nil, fmt.Errorf("payments: admin list products: %w", err)

backend/internal/payments/store_intake.go

@@ -151,7 +151,6 @@ type newOrder struct {
 	amount    Money
 	origin    Source
 	provider  string
-	shop      string
 }
 
 // createOrder inserts a pending order.
@@ -160,12 +159,12 @@ func (s *Store) createOrder(ctx context.Context, o newOrder, now time.Time) erro
 		table.Orders.OrderID, table.Orders.AccountID, table.Orders.Platform,
 		table.Orders.ProductID, table.Orders.ExpectedAmount, table.Orders.Currency,
 		table.Orders.Origin, table.Orders.Status, table.Orders.Provider,
-		table.Orders.CreatedAt, table.Orders.UpdatedAt, table.Orders.Shop,
+		table.Orders.CreatedAt, table.Orders.UpdatedAt,
 	).VALUES(
 		o.orderID, o.accountID, o.platform,
 		o.productID, o.amount.Minor(), string(o.amount.Currency()),
 		string(o.origin), "pending", o.provider,
-		now, now, o.shop,
+		now, now,
 	)
 	if _, err := stmt.ExecContext(ctx, s.db); err != nil {
 		return fmt.Errorf("payments: create order: %w", err)
@@ -414,18 +413,6 @@ func (s *Store) rewardConfig(ctx context.Context) (payout, dailyCap, hourlyCap i
 	return int(cfg.RewardedPayoutChips), int(cfg.RewardDailyCap), int(cfg.RewardHourlyCap), nil
 }
 
-// setRewardConfig updates the rewarded payout and the per-day and per-hour caps on the singleton
-// config row (no WHERE — the table holds exactly one row). Non-negativity is validated by the caller
-// and also enforced by the config CHECK constraints.
-func (s *Store) setRewardConfig(ctx context.Context, payout, dailyCap, hourlyCap int) error {
-	if _, err := s.db.ExecContext(ctx,
-		`UPDATE payments.config SET rewarded_payout_chips=$1, reward_daily_cap=$2, reward_hourly_cap=$3`,
-		payout, dailyCap, hourlyCap); err != nil {
-		return fmt.Errorf("payments: set reward config: %w", err)
-	}
-	return nil
-}
-
 // creditReward credits a rewarded-video view's chips to the funded segment, client-attested (VK Mini
 // App ads expose no server verify). It reads the payout and daily cap from config: a 0 payout
 // (unconfigured) or a reached cap credits nothing. It is idempotent on the client nonce (dedup on the

backend/internal/payments/store_statement.go

@@ -74,39 +74,9 @@ func (s *Store) accountStatement(ctx context.Context, accountID uuid.UUID) (Stat
 			CreatedAt:         r.CreatedAt,
 		})
 	}
-
-	// Annotate direct-rail entries with the merchant shop (channel) their order was issued through
-	// (E10/D44), keyed by the ledger's order id. Non-direct / order-less entries stay "".
-	shops, err := s.orderShops(ctx, accountID)
-	if err != nil {
-		return Statement{}, err
-	}
-	for i := range out.Ledger {
-		out.Ledger[i].Shop = shops[out.Ledger[i].OrderID]
-	}
 	return out, nil
 }
 
-// orderShops maps an account's order ids (as strings) to the merchant shop (channel) each direct
-// order was issued through, for annotating the ledger report (E10/D44). Orders with an empty shop
-// (non-direct or pre-split) are omitted, so a lookup miss yields "".
-func (s *Store) orderShops(ctx context.Context, accountID uuid.UUID) (map[string]string, error) {
-	var rows []model.Orders
-	if err := postgres.SELECT(table.Orders.OrderID, table.Orders.Shop).
-		FROM(table.Orders).
-		WHERE(table.Orders.AccountID.EQ(postgres.UUID(accountID))).
-		QueryContext(ctx, s.db, &rows); err != nil {
-		return nil, fmt.Errorf("payments: load order shops %s: %w", accountID, err)
-	}
-	m := make(map[string]string, len(rows))
-	for _, r := range rows {
-		if r.Shop != "" {
-			m[r.OrderID.String()] = r.Shop
-		}
-	}
-	return m, nil
-}
-
 // allLedger reads the entire append-only ledger (all accounts, newest first) for the admin export.
 func (s *Store) allLedger(ctx context.Context) ([]LedgerExportRow, error) {
 	var rows []model.Ledger

backend/internal/postgres/jet/payments/model/orders.go

@@ -25,5 +25,4 @@ type Orders struct {
 	ProviderPaymentID *string
 	CreatedAt         time.Time
 	UpdatedAt         time.Time
-	Shop              string
 }

backend/internal/postgres/jet/payments/table/orders.go

@@ -29,7 +29,6 @@ type ordersTable struct {
 	ProviderPaymentID postgres.ColumnString
 	CreatedAt         postgres.ColumnTimestampz
 	UpdatedAt         postgres.ColumnTimestampz
-	Shop              postgres.ColumnString
 
 	AllColumns     postgres.ColumnList
 	MutableColumns postgres.ColumnList
@@ -83,10 +82,9 @@ func newOrdersTableImpl(schemaName, tableName, alias string) ordersTable {
 		ProviderPaymentIDColumn = postgres.StringColumn("provider_payment_id")
 		CreatedAtColumn         = postgres.TimestampzColumn("created_at")
 		UpdatedAtColumn         = postgres.TimestampzColumn("updated_at")
-		ShopColumn              = postgres.StringColumn("shop")
+		allColumns              = postgres.ColumnList{OrderIDColumn, AccountIDColumn, PlatformColumn, ProductIDColumn, ExpectedAmountColumn, CurrencyColumn, OriginColumn, StatusColumn, ProviderColumn, ProviderPaymentIDColumn, CreatedAtColumn, UpdatedAtColumn}
-		allColumns              = postgres.ColumnList{OrderIDColumn, AccountIDColumn, PlatformColumn, ProductIDColumn, ExpectedAmountColumn, CurrencyColumn, OriginColumn, StatusColumn, ProviderColumn, ProviderPaymentIDColumn, CreatedAtColumn, UpdatedAtColumn, ShopColumn}
+		mutableColumns          = postgres.ColumnList{AccountIDColumn, PlatformColumn, ProductIDColumn, ExpectedAmountColumn, CurrencyColumn, OriginColumn, StatusColumn, ProviderColumn, ProviderPaymentIDColumn, CreatedAtColumn, UpdatedAtColumn}
-		mutableColumns          = postgres.ColumnList{AccountIDColumn, PlatformColumn, ProductIDColumn, ExpectedAmountColumn, CurrencyColumn, OriginColumn, StatusColumn, ProviderColumn, ProviderPaymentIDColumn, CreatedAtColumn, UpdatedAtColumn, ShopColumn}
+		defaultColumns          = postgres.ColumnList{StatusColumn, CreatedAtColumn, UpdatedAtColumn}
-		defaultColumns          = postgres.ColumnList{StatusColumn, CreatedAtColumn, UpdatedAtColumn, ShopColumn}
 	)
 
 	return ordersTable{
@@ -105,7 +103,6 @@ func newOrdersTableImpl(schemaName, tableName, alias string) ordersTable {
 		ProviderPaymentID: ProviderPaymentIDColumn,
 		CreatedAt:         CreatedAtColumn,
 		UpdatedAt:         UpdatedAtColumn,
-		Shop:              ShopColumn,
 
 		AllColumns:     allColumns,
 		MutableColumns: mutableColumns,

backend/internal/postgres/migrations/00015_orders_shop.sql

@@ -1,13 +0,0 @@
--- Multi-shop direct rail (E10/D44): record which Robokassa merchant shop (channel) issued a direct
--- order — "web" / "android" (ios later) — so the admin financial report can break direct payments
--- down by channel. Only the direct rail is per-channel; other rails leave it "". Additive only (a
--- defaulted column), applies forward via goose with no data rewrite (no contour wipe); an image
--- rollback ignores the column.
--- +goose Up
-
-ALTER TABLE payments.orders
-    ADD COLUMN shop text NOT NULL DEFAULT '';
-
--- +goose Down
-
-ALTER TABLE payments.orders DROP COLUMN shop;

backend/internal/postgres/migrations/00016_payment_availability.sql

@@ -1,26 +0,0 @@
--- Payment availability controls (D45/D46): a per-rail operational kill switch with a localized message,
--- and a per-account purchase override. Both let an operator disable payments live from the admin —
--- a whole rail/channel, or one account — and explain why to the user on a purchase attempt. Additive
--- (new tables) — applies forward via goose with no data rewrite (no contour wipe); an image rollback
--- ignores both tables. Fail-open by design: a rail with no row is enabled; an account with no row
--- follows the rail switch.
--- +goose Up
-
-CREATE TABLE payments.rail_status (
-    rail text PRIMARY KEY,
-    enabled boolean NOT NULL DEFAULT true,
-    message_ru text NOT NULL DEFAULT '',
-    message_en text NOT NULL DEFAULT '',
-    updated_at timestamptz NOT NULL DEFAULT now()
-);
-
-CREATE TABLE payments.account_payment_override (
-    account_id uuid PRIMARY KEY,
-    allow boolean NOT NULL,
-    updated_at timestamptz NOT NULL DEFAULT now()
-);
-
--- +goose Down
-
-DROP TABLE payments.account_payment_override;
-DROP TABLE payments.rail_status;

backend/internal/robokassa/shops.go

@@ -1,54 +0,0 @@
-package robokassa
-
-// Shops is a set of Robokassa merchant shops keyed by channel — the subtype of the trusted
-// X-Platform signal for the direct rail ("web", "android"; "ios" later). The direct rail routes a
-// payment to the per-channel shop for separate merchant accounts, accounting and receipts, while
-// every shop still credits the one direct wallet (docs/PAYMENTS_DECISIONS_ru.md D42). An empty set
-// leaves the direct order and Result-callback endpoints unregistered.
-type Shops map[string]Config
-
-// Channel constants name the direct-rail X-Platform subtypes a shop is keyed by. ChannelWeb is the
-// default: an unknown or empty channel routes here on the order side, and the legacy single-shop
-// configuration seeds it.
-const (
-	ChannelWeb     = "web"
-	ChannelAndroid = "android"
-)
-
-// Shop returns the shop that issues an order for channel, falling back to the web shop when channel
-// is unknown, empty or not configured. The fallback is safe: routing only chooses the merchant
-// account and receipt, never the credited wallet (always direct, D42), so a mis-attributed channel
-// costs at most accounting accuracy, not money. The second result is false when neither the channel
-// nor the web shop has a merchant login (the rail is unconfigured).
-func (s Shops) Shop(channel string) (Config, bool) {
-	if channel != "" {
-		if c, ok := s[channel]; ok && c.MerchantLogin != "" {
-			return c, true
-		}
-	}
-	if c, ok := s[ChannelWeb]; ok && c.MerchantLogin != "" {
-		return c, true
-	}
-	return Config{}, false
-}
-
-// Verifier returns the shop whose Password2 verifies a Result callback delivered to channel's
-// dedicated Result route. Unlike Shop it does not fall back to web: each shop's callback is verified
-// only by that shop's own credentials, so a route with no configured shop reports false (and its
-// handler answers as unregistered). The second result is false when channel has no merchant login.
-func (s Shops) Verifier(channel string) (Config, bool) {
-	if c, ok := s[channel]; ok && c.MerchantLogin != "" {
-		return c, true
-	}
-	return Config{}, false
-}
-
-// Configured reports whether at least one shop has a merchant login (the direct rail is live).
-func (s Shops) Configured() bool {
-	for _, c := range s {
-		if c.MerchantLogin != "" {
-			return true
-		}
-	}
-	return false
-}

backend/internal/robokassa/shops_test.go

@@ -1,52 +0,0 @@
-package robokassa
-
-import "testing"
-
-func TestShopsShopRouting(t *testing.T) {
-	shops := Shops{
-		ChannelWeb:     {MerchantLogin: "webshop", Password1: "w1", Password2: "w2"},
-		ChannelAndroid: {MerchantLogin: "androidshop", Password1: "a1", Password2: "a2"},
-	}
-	// Order side: the exact channel wins.
-	if c, ok := shops.Shop(ChannelAndroid); !ok || c.MerchantLogin != "androidshop" {
-		t.Errorf("Shop(android) = %q/%v, want androidshop/true", c.MerchantLogin, ok)
-	}
-	// Order side: an unknown or empty channel falls back to the web shop (safe — always credits direct).
-	if c, ok := shops.Shop("ios"); !ok || c.MerchantLogin != "webshop" {
-		t.Errorf("Shop(ios) = %q/%v, want webshop/true (web fallback)", c.MerchantLogin, ok)
-	}
-	if c, ok := shops.Shop(""); !ok || c.MerchantLogin != "webshop" {
-		t.Errorf("Shop(empty) = %q/%v, want webshop/true (web fallback)", c.MerchantLogin, ok)
-	}
-	// No web shop and an unknown channel → unconfigured.
-	if _, ok := (Shops{ChannelAndroid: {MerchantLogin: "androidshop", Password1: "a1", Password2: "a2"}}).Shop("ios"); ok {
-		t.Error("Shop(ios) with no web shop returned ok, want false")
-	}
-}
-
-func TestShopsVerifierIsStrict(t *testing.T) {
-	shops := Shops{
-		ChannelWeb:     {MerchantLogin: "webshop", Password1: "w1", Password2: "w2"},
-		ChannelAndroid: {MerchantLogin: "androidshop", Password1: "a1", Password2: "a2"},
-	}
-	// Callback side: the exact channel's own credentials, no web fallback (each callback is verified
-	// only by its own shop's Password2).
-	if c, ok := shops.Verifier(ChannelAndroid); !ok || c.MerchantLogin != "androidshop" {
-		t.Errorf("Verifier(android) = %q/%v, want androidshop/true", c.MerchantLogin, ok)
-	}
-	if _, ok := shops.Verifier("ios"); ok {
-		t.Error("Verifier(ios) returned ok, want false (no fallback)")
-	}
-}
-
-func TestShopsConfigured(t *testing.T) {
-	if (Shops{}).Configured() {
-		t.Error("an empty set reported configured")
-	}
-	if (Shops{ChannelWeb: {}}).Configured() {
-		t.Error("a shop with no merchant login reported configured")
-	}
-	if !(Shops{ChannelWeb: {MerchantLogin: "s", Password1: "1", Password2: "2"}}).Configured() {
-		t.Error("a configured shop reported not configured")
-	}
-}

backend/internal/server/handlers.go

@@ -74,9 +74,6 @@ func (s *Server) registerRoutes() {
 		u.POST("/wallet/buy", s.handleWalletBuy)
 		// A rewarded-video credit (VK ads): client-attested + a config daily cap.
 		u.POST("/wallet/reward", s.handleWalletReward)
-		// The public-offer price list (§4.4) as markdown, for the render sidecar that serves the
-		// /offer/ page. Internal (off the edge allow-list); called by the renderer, not the gateway.
-		s.internal.GET("/offer/pricing", s.handleOfferPricing)
 	}
 	if s.payments != nil {
 		// The money order endpoint dispatches by rail (direct → Robokassa, vk → VK); an
@@ -89,7 +86,7 @@ func (s *Server) registerRoutes() {
 		// payment over the reverse bot-link; the gateway proxies both onto these gateway-only routes.
 		s.internal.POST("/payments/telegram/precheckout", s.handleTelegramPreCheckout)
 		s.internal.POST("/payments/telegram/payment", s.handleTelegramPayment)
-		if s.robokassa.Configured() {
+		if s.robokassa.MerchantLogin != "" {
 			s.internal.POST("/payments/robokassa/result", s.handleRobokassaResult)
 		}
 	}

backend/internal/server/handlers_admin_catalog.go

@@ -33,71 +33,21 @@ var priceFields = []struct {
 	{"price_chip", "", payments.CurrencyChip},
 }
 
-// consoleCatalog lists the catalog products with their composition, prices, transacted flag, and the
+// consoleCatalog lists every product (active and archived) with its composition, prices, transacted
-// inline create form. It shows active products by default; ?all=1 also lists the archived ones (the
+// flag, and the inline create form.
-// active/all toggle).
 func (s *Server) consoleCatalog(c *gin.Context) {
-	showAll := c.Query("all") == "1"
+	products, err := s.payments.AdminCatalog(c.Request.Context())
-	products, err := s.payments.AdminCatalog(c.Request.Context(), showAll)
 	if err != nil {
 		s.consoleError(c, err)
 		return
 	}
-	// Order the list like the public offer: sales (chip packs) first, then the chip-exchange values,
+	var view adminconsole.CatalogView
-	// grouped and price-sorted the same way, so the console mirrors what a buyer sees.
-	payments.SortAdminCatalog(products)
-	payout, daily, hourly, err := s.payments.RewardConfig(c.Request.Context())
-	if err != nil {
-		s.consoleError(c, err)
-		return
-	}
-	rails, err := s.payments.RailStatuses(c.Request.Context())
-	if err != nil {
-		s.consoleError(c, err)
-		return
-	}
-	view := adminconsole.CatalogView{ShowAll: showAll, RewardPayout: payout, RewardDailyCap: daily, RewardHourlyCap: hourly}
-	for _, rail := range payments.KnownRails {
-		a := rails[rail]
-		view.Rails = append(view.Rails, adminconsole.RailStatusRow{Rail: rail, Enabled: a.Enabled, MessageRU: a.MessageRU, MessageEN: a.MessageEN})
-	}
 	for _, p := range products {
 		view.Products = append(view.Products, catalogRow(p))
 	}
 	s.renderConsole(c, "catalog", "catalog", "Catalog", view)
 }
 
-// consoleSetReward updates the rewarded-video config (chips per view plus the per-day and per-hour
-// caps) from the catalog page's rewarded-ads form. A blank field reads as 0; a negative value is
-// refused by the service.
-func (s *Server) consoleSetReward(c *gin.Context) {
-	payout, _ := strconv.Atoi(strings.TrimSpace(c.PostForm("reward_payout")))
-	daily, _ := strconv.Atoi(strings.TrimSpace(c.PostForm("reward_daily")))
-	hourly, _ := strconv.Atoi(strings.TrimSpace(c.PostForm("reward_hourly")))
-	if err := s.payments.SetRewardConfig(c.Request.Context(), payout, daily, hourly); err != nil {
-		s.renderConsoleMessage(c, "Update failed", err.Error(), catalogBack)
-		return
-	}
-	s.renderConsoleMessage(c, "Saved", "the rewarded-ads config was updated", catalogBack)
-}
-
-// consoleSetRailStatus toggles a payment rail's operational kill switch and its user-facing
-// off-message (per language) from the catalog page's payment-availability form. An unchecked box
-// disables the rail; an unknown rail is refused by the service.
-func (s *Server) consoleSetRailStatus(c *gin.Context) {
-	rail := strings.TrimSpace(c.PostForm("rail"))
-	a := payments.RailAvailability{
-		Enabled:   c.PostForm("enabled") == "on",
-		MessageRU: strings.TrimSpace(c.PostForm("message_ru")),
-		MessageEN: strings.TrimSpace(c.PostForm("message_en")),
-	}
-	if err := s.payments.SetRailStatus(c.Request.Context(), rail, a); err != nil {
-		s.renderConsoleMessage(c, "Update failed", err.Error(), catalogBack)
-		return
-	}
-	s.renderConsoleMessage(c, "Saved", "payment availability was updated", catalogBack)
-}
-
 // catalogRow projects a product into its list row.
 func catalogRow(p payments.AdminProduct) adminconsole.ProductRow {
 	row := adminconsole.ProductRow{ID: p.ID.String(), Title: p.Title, Active: p.Active, Transacted: p.Transacted}
@@ -116,7 +66,7 @@ func (s *Server) consoleCatalogDetail(c *gin.Context) {
 	if !ok {
 		return
 	}
-	products, err := s.payments.AdminCatalog(c.Request.Context(), true) // include archived: the detail form edits any product
+	products, err := s.payments.AdminCatalog(c.Request.Context())
 	if err != nil {
 		s.consoleError(c, err)
 		return
@@ -289,7 +239,7 @@ func (s *Server) consoleGrantProduct(c *gin.Context) {
 // bundles, including archived ones — chips and tournament products are excluded).
 func (s *Server) grantForm(ctx context.Context) adminconsole.GrantFormView {
 	fv := adminconsole.GrantFormView{Present: true, Origins: []string{"direct", "vk", "telegram"}}
-	products, err := s.payments.AdminCatalog(ctx, true)
+	products, err := s.payments.AdminCatalog(ctx)
 	if err != nil {
 		return fv
 	}

backend/internal/server/handlers_admin_console.go

@@ -61,7 +61,6 @@ func (s *Server) registerConsole(router *gin.Engine) {
 	gm.POST("/users/:id/grant", s.consoleGrant)
 	gm.POST("/users/:id/grant-product", s.consoleGrantProduct)
 	gm.POST("/users/:id/refund", s.consoleRefund)
-	gm.POST("/users/:id/purchase-override", s.consoleSetPurchaseOverride)
 	gm.POST("/users/:id/delete", s.consoleDeleteUser)
 	gm.GET("/reasons", s.consoleReasons)
 	gm.POST("/reasons", s.consoleCreateReason)
@@ -113,8 +112,6 @@ func (s *Server) registerConsole(router *gin.Engine) {
 	if s.payments != nil {
 		gm.GET("/catalog", s.consoleCatalog)
 		gm.POST("/catalog", s.consoleCreateProduct)
-		gm.POST("/catalog/reward", s.consoleSetReward)
-		gm.POST("/catalog/rail-status", s.consoleSetRailStatus)
 		gm.GET("/catalog/:id", s.consoleCatalogDetail)
 		gm.POST("/catalog/:id", s.consoleUpdateProduct)
 		gm.POST("/catalog/:id/archive", s.consoleArchiveProduct)
@@ -463,9 +460,6 @@ func (s *Server) consoleUserDetail(c *gin.Context) {
 			s.log.Warn("console: account statement failed", zap.String("account", id.String()), zap.Error(err))
 		}
 		view.Grant = s.grantForm(ctx)
-		if ov, oerr := s.payments.PurchaseOverrideFor(ctx, id); oerr == nil {
-			view.PurchaseOverride = overrideName(ov)
-		}
 	}
 	s.renderConsole(c, "user_detail", "users", acc.DisplayName, view)
 }
@@ -487,54 +481,13 @@ func financeView(stmt payments.Statement) adminconsole.FinanceView {
 	for _, e := range stmt.Ledger {
 		fv.Ledger = append(fv.Ledger, adminconsole.LedgerRow{
 			Kind: e.Kind, Source: e.Source, Origin: e.Origin, ChipsDelta: e.ChipsDelta,
-			Product: e.ProductID, Order: e.OrderID, Provider: e.Provider, Shop: e.Shop, Snapshot: e.Snapshot,
+			Product: e.ProductID, Order: e.OrderID, Provider: e.Provider, Snapshot: e.Snapshot,
 			At: fmtTime(e.CreatedAt),
 		})
 	}
 	return fv
 }
 
-// overrideName renders a purchase override as the form/select value ("default"/"allow"/"deny").
-func overrideName(ov payments.PurchaseOverride) string {
-	switch ov {
-	case payments.OverrideAllow:
-		return "allow"
-	case payments.OverrideDeny:
-		return "deny"
-	default:
-		return "default"
-	}
-}
-
-// consoleSetPurchaseOverride sets or clears an account's per-account purchase override (allow / deny
-// / default) from the user card. "allow" bypasses only the operational rail switch, never the
-// security gates; "default" clears the override (deletes the row).
-func (s *Server) consoleSetPurchaseOverride(c *gin.Context) {
-	id, ok := s.consoleUUID(c, "/_gm/users")
-	if !ok {
-		return
-	}
-	back := "/_gm/users/" + id.String()
-	if s.payments == nil {
-		s.renderConsoleMessage(c, "Unavailable", "payments are not configured", back)
-		return
-	}
-	var ov payments.PurchaseOverride
-	switch c.PostForm("override") {
-	case "allow":
-		ov = payments.OverrideAllow
-	case "deny":
-		ov = payments.OverrideDeny
-	default:
-		ov = payments.OverrideDefault
-	}
-	if err := s.payments.SetPurchaseOverride(c.Request.Context(), id, ov); err != nil {
-		s.renderConsoleMessage(c, "Update failed", err.Error(), back)
-		return
-	}
-	s.renderConsoleMessage(c, "Saved", "the purchase override was updated", back)
-}
-
 // relationRows maps the social graph entries to the cross-linked, date-formatted rows the
 // user card renders.
 func relationRows(rels []social.AdminRelation) []adminconsole.RelationRow {
@@ -613,7 +566,6 @@ func (s *Server) consoleGameDetail(c *gin.Context) {
 		Status: g.Status, Players: g.Players, ToMove: g.ToMove, EndReason: g.EndReason,
 		MoveCount: g.MoveCount, CreatedAt: fmtTime(g.CreatedAt), UpdatedAt: fmtTime(g.UpdatedAt),
 		FinishedAt: fmtTimePtr(g.FinishedAt), VsAI: g.VsAI,
-		MultipleWordsPerTurn: g.MultipleWordsPerTurn,
 	}
 	// Resolve seats and detect robot seats; capture the human opponent's timezone, which
 	// anchors the robot's sleep window for the next-move ETA.

backend/internal/server/handlers_auth.go

@@ -160,20 +160,16 @@ type guestAuthRequest struct {
 	// Subtype is the client-reported device family (ios/android/web) of this direct
 	// (web/native) session; there is no external signer, so it is recorded best-effort.
 	Subtype string `json:"subtype"`
-	// Language is the client's detected interface locale, seeding the fresh guest's
-	// interface language (best-effort; an unsupported/absent value keeps the 'en' default).
-	Language string `json:"language"`
 }
 
 // handleGuestAuth provisions a fresh ephemeral guest account and mints a session,
-// seeding its time zone from the optional detected browser offset and its interface
+// seeding its time zone from the optional detected browser offset.
-// language from the optional detected locale.
 func (s *Server) handleGuestAuth(c *gin.Context) {
-	// The body is optional: an absent or malformed one simply yields no time-zone/language seed
+	// The body is optional: an absent or malformed one simply yields no time-zone seed
-	// (the account keeps the UTC / 'en' defaults), so a bind error must not fail the bootstrap.
+	// (the account keeps the UTC default), so a bind error must not fail the bootstrap.
 	var req guestAuthRequest
 	_ = c.ShouldBindJSON(&req)
-	acc, err := s.accounts.ProvisionGuest(c.Request.Context(), req.BrowserTZ, req.Language)
+	acc, err := s.accounts.ProvisionGuest(c.Request.Context(), req.BrowserTZ)
 	if err != nil {
 		s.abortErr(c, err)
 		return

backend/internal/server/handlers_intake.go

@@ -12,7 +12,6 @@ import (
 	"go.uber.org/zap"
 
 	"scrabble/backend/internal/payments"
-	"scrabble/backend/internal/robokassa"
 )
 
 // Ledger/order provider tags per rail.
@@ -67,25 +66,9 @@ func (s *Server) handleWalletOrder(c *gin.Context) {
 		s.abortErr(c, err)
 		return
 	}
-	// Operational availability gate (D45/D46): the per-rail kill switch + the per-account override,
-	// before any order is opened. Orthogonal to the security gates in the rail branches below — a
-	// per-account "allow" override bypasses only this switch, never those. The reason is localized to
-	// the account's language for the user.
-	lang := ""
-	if acc, aerr := s.accounts.GetByID(ctx, uid); aerr == nil {
-		lang = acc.PreferredLanguage
-	}
-	if ok, reason, aerr := s.payments.CanPurchase(ctx, uid, payments.RailKey(cxt.Kind, cxt.Subtype), lang); aerr != nil {
-		s.abortErr(c, aerr)
-		return
-	} else if !ok {
-		c.AbortWithStatusJSON(http.StatusServiceUnavailable, errorResponse{Error: errorBody{Code: "payment_unavailable", Message: reason}})
-		return
-	}
 	switch cxt.Kind {
 	case payments.SourceDirect:
-		shop, ok := s.robokassa.Shop(cxt.Subtype)
+		if s.robokassa.MerchantLogin == "" {
-		if !ok {
 			c.AbortWithStatusJSON(http.StatusNotImplemented, errorResponse{Error: errorBody{Code: "rail_unavailable", Message: "this payment method is not available"}})
 			return
 		}
@@ -106,7 +89,7 @@ func (s *Server) handleWalletOrder(c *gin.Context) {
 		}
 		c.JSON(http.StatusOK, walletOrderResponse{
 			OrderID:     res.OrderID.String(),
-			RedirectURL: shop.PaymentURL(res.OrderID, res.Amount.Major(), res.Title),
+			RedirectURL: s.robokassa.PaymentURL(res.OrderID, res.Amount.Major(), res.Title),
 			Rail:        providerRobokassa,
 		})
 	case payments.SourceVK:
@@ -153,16 +136,7 @@ func (s *Server) handleRobokassaResult(c *gin.Context) {
 	for k, val := range params {
 		v.Set(k, val)
 	}
-	// The per-shop Result route carries the channel as ?channel=; the legacy bare route defaults to
+	orderID, outSum, ok := s.robokassa.VerifyResult(v)
-	// the web shop. Each channel is verified only by its own shop's Password2 (Verifier is strict).
-	channel := c.DefaultQuery("channel", robokassa.ChannelWeb)
-	shop, ok := s.robokassa.Verifier(channel)
-	if !ok {
-		s.log.Warn("robokassa result: unknown shop channel", zap.String("channel", channel))
-		c.String(http.StatusBadRequest, "bad sign")
-		return
-	}
-	orderID, outSum, ok := shop.VerifyResult(v)
 	if !ok {
 		s.log.Warn("robokassa result: bad signature")
 		c.String(http.StatusBadRequest, "bad sign")

backend/internal/server/handlers_link.go

@@ -285,12 +285,6 @@ func (s *Server) handleLinkVKMerge(c *gin.Context) {
 // or a completed link (the active account's refreshed profile).
 func (s *Server) confirmResultResponse(c *gin.Context, activeID uuid.UUID, res link.ConfirmResult) linkResultResponse {
 	ctx := c.Request.Context()
-	if res.Merged {
-		// A guest initiator's merge ran inline (the guest-primary rule; no confirmation step),
-		// so render the completed merge — the client adopts the switched session and lands on
-		// the surviving durable account as if it simply logged in.
-		return s.mergeResultResponse(c, res.Merge)
-	}
 	if res.MergeRequired {
 		out := linkResultResponse{Status: "merge_required", SecondaryUserID: res.SecondaryID.String()}
 		if acc, err := s.accounts.GetByID(ctx, res.SecondaryID); err == nil {

backend/internal/server/handlers_wallet.go

@@ -112,22 +112,6 @@ func (s *Server) handleWalletCatalog(c *gin.Context) {
 	c.JSON(http.StatusOK, catalogDTOFrom(view))
 }
 
-// handleOfferPricing serves the public-offer price list (§4.4) as markdown — the two catalog tables
-// projected from the active products. The render sidecar fetches it and splices it into the offer
-// markdown before rendering the /offer/ page. Internal, non-public: the /api/v1/internal group is
-// off the edge allow-list, and the value is served from the payments cache (no per-request query in
-// the steady state). Called by the renderer, not the gateway.
-func (s *Server) handleOfferPricing(c *gin.Context) {
-	md, err := s.payments.OfferPricing(c.Request.Context())
-	if err != nil {
-		s.log.Error("offer pricing projection failed", zap.Error(err))
-		c.String(http.StatusInternalServerError, "offer pricing unavailable")
-		return
-	}
-	c.Header("Content-Type", "text/markdown; charset=utf-8")
-	c.String(http.StatusOK, md)
-}
-
 // handleWallet returns the caller's wallet — the segments and benefits visible in the current
 // trusted execution context, plus the rewarded-video payout available here (0 outside VK or when
 // unconfigured), which gates the client's "watch for chips" button.

backend/internal/server/server.go

@@ -115,9 +115,9 @@ type Deps struct {
 	// Renderer is the image-render sidecar client for the PNG export artifact. A
 	// nil Renderer makes the PNG download answer 404 (the GCG artifact still works).
 	Renderer *render.Client
-	// Robokassa configures the direct-rail (RUB) provider — one merchant shop per channel; an empty
+	// Robokassa configures the direct-rail (RUB) provider; an empty MerchantLogin leaves the
-	// set leaves the order and Result-callback endpoints unregistered.
+	// order and Result-callback endpoints unregistered.
-	Robokassa robokassa.Shops
+	Robokassa robokassa.Config
 }
 
 // Server owns the gin engine, the underlying HTTP server and the readiness
@@ -146,7 +146,7 @@ type Server struct {
 	ads         *ads.Service
 	payments    *payments.Service
 	gamelimits  *gamelimits.Service
-	robokassa   robokassa.Shops
+	robokassa   robokassa.Config
 	notifier    notify.Publisher
 	console     *adminconsole.Renderer
 	exportKey   []byte

backend/internal/telemetry/middleware.go

@@ -56,9 +56,6 @@ func Middleware(logger *zap.Logger) gin.HandlerFunc {
 			zap.String("path", route),
 			zap.Int("status", status),
 			zap.Duration("latency", elapsed),
-			// The gateway forwards the real caller as X-Forwarded-For (and Caddy does for /_gm), which
-			// gin resolves here — so the access log carries the client IP, not the gateway's connection.
-			zap.String("client_ip", c.ClientIP()),
 		}
 		fields = append(fields, TraceFieldsFromContext(ctx)...)