@px-lsp/server 0.1.0

package/src/games/jomini/variables.ts

@@ -0,0 +1,134 @@
+/**
+ * Variable/flag/list vocabulary of the Jomini script engine, shared by every
+ * Jomini game (same `set_variable` / `add_to_variable_list` / flag effects in
+ * all of them). Consumed by reference extraction, completion, hover and
+ * semantic tokens; game profiles spread {@link JOMINI_VARIABLE_BLOCK_REFS}
+ * into their own block-ref tables.
+ */
+
+/**
+ * Variable vocabulary shared by reference extraction (server) and completion.
+ * `var:` reads what set_variable wrote on the current scope object,
+ * `local_var:` / `global_var:` the other storage classes. Lists live in the
+ * same storage (has_variable is true for a list) — see references.ts.
+ */
+export const VARIABLE_SET_KINDS: Record<string, string> = {
+  set_variable: "variable",
+  change_variable: "variable",
+  set_local_variable: "local_variable",
+  change_local_variable: "local_variable",
+  set_global_variable: "global_variable",
+  change_global_variable: "global_variable",
+};
+export const VARIABLE_LIST_SET_KINDS: Record<string, string> = {
+  add_to_variable_list: "variable_list",
+  add_to_local_variable_list: "local_variable_list",
+  add_to_global_variable_list: "global_variable_list",
+};
+/** Effects/triggers that READ a variable by name (scalar or `{ name = X }`). */
+export const VARIABLE_READ_KINDS: Record<string, string> = {
+  has_variable: "variable",
+  remove_variable: "variable",
+  clamp_variable: "variable",
+  round_variable: "variable",
+  has_local_variable: "local_variable",
+  remove_local_variable: "local_variable",
+  clamp_local_variable: "local_variable",
+  round_local_variable: "local_variable",
+  has_global_variable: "global_variable",
+  remove_global_variable: "global_variable",
+  clamp_global_variable: "global_variable",
+  round_global_variable: "global_variable",
+  has_variable_list: "variable_list",
+  clear_variable_list: "variable_list",
+  variable_list_size: "variable_list",
+  is_target_in_variable_list: "variable_list",
+  remove_list_variable: "variable_list",
+  has_local_variable_list: "local_variable_list",
+  clear_local_variable_list: "local_variable_list",
+  local_variable_list_size: "local_variable_list",
+  is_target_in_local_variable_list: "local_variable_list",
+  remove_list_local_variable: "local_variable_list",
+  has_global_variable_list: "global_variable_list",
+  clear_global_variable_list: "global_variable_list",
+  global_variable_list_size: "global_variable_list",
+  is_target_in_global_variable_list: "global_variable_list",
+  remove_list_global_variable: "global_variable_list",
+};
+/** `var:x` → candidate definition kinds (scalar first, list second). */
+export const VAR_PREFIX_KINDS: Record<string, string[]> = {
+  var: ["variable", "variable_list"],
+  local_var: ["local_variable", "local_variable_list"],
+  global_var: ["global_variable", "global_variable_list"],
+};
+/** All variable definition kinds (index/completion registration). */
+export const VARIABLE_KINDS = [
+  "variable",
+  "local_variable",
+  "global_variable",
+  "variable_list",
+  "local_variable_list",
+  "global_variable_list",
+];
+
+/**
+ * Block-local ref fields for the variable ops: in-list iterators
+ * (`every_in_list = { variable = X }`) and the block forms of the
+ * change/clamp/round/membership effects. Spread into each profile's
+ * blockRefFields table.
+ */
+export const JOMINI_VARIABLE_BLOCK_REFS: Record<string, Record<string, string[]>> = {
+  // Variable list iterators: `variable = X` names a variable list of the
+  // matching storage class; `list = X` names an add_to_list-style ad-hoc list.
+  ...inListIteratorRefs(),
+  // Block-form variable ops: `name = X` references an existing variable.
+  is_target_in_variable_list: { name: ["variable_list"] },
+  remove_list_variable: { name: ["variable_list"] },
+  variable_list_size: { name: ["variable_list"] },
+  is_target_in_local_variable_list: { name: ["local_variable_list"] },
+  remove_list_local_variable: { name: ["local_variable_list"] },
+  local_variable_list_size: { name: ["local_variable_list"] },
+  is_target_in_global_variable_list: { name: ["global_variable_list"] },
+  remove_list_global_variable: { name: ["global_variable_list"] },
+  global_variable_list_size: { name: ["global_variable_list"] },
+  change_variable: { name: ["variable"] },
+  clamp_variable: { name: ["variable"] },
+  round_variable: { name: ["variable"] },
+  change_local_variable: { name: ["local_variable"] },
+  clamp_local_variable: { name: ["local_variable"] },
+  round_local_variable: { name: ["local_variable"] },
+  change_global_variable: { name: ["global_variable"] },
+  clamp_global_variable: { name: ["global_variable"] },
+  round_global_variable: { name: ["global_variable"] },
+};
+
+function inListIteratorRefs(): Record<string, Record<string, string[]>> {
+  const out: Record<string, Record<string, string[]>> = {};
+  for (const prefix of ["every", "any", "random", "ordered"]) {
+    out[`${prefix}_in_list`] = { variable: ["variable_list"], list: ["list"] };
+    out[`${prefix}_in_local_list`] = { variable: ["local_variable_list"], list: ["list"] };
+    out[`${prefix}_in_global_list`] = { variable: ["global_variable_list"], list: ["list"] };
+  }
+  return out;
+}
+
+const FLAG_REF_KEY = /^(?:has|remove)_[a-z_]*flag$/;
+const LIST_REF_KEYS = new Set(["is_in_list", "is_target_in_list", "remove_from_list", "list"]);
+
+/**
+ * Ref kinds for key families too open-ended to enumerate in a profile's
+ * refFields: per-scope flag triggers/effects (`has_character_flag`,
+ * `remove_house_flag`, … → flags declared at `add_*_flag` sites) and list
+ * membership (`is_in_list`, the `list =` key of in-list iterators → names
+ * declared at `add_to_list`).
+ */
+export function dynamicRefKinds(key: string): string[] | null {
+  if (FLAG_REF_KEY.test(key)) return ["flag"];
+  if (LIST_REF_KEYS.has(key)) return ["list"];
+  const varKind = VARIABLE_READ_KINDS[key];
+  if (varKind) {
+    // Scalar reads accept lists too (has_variable is true for a list variable).
+    return varKind.endsWith("_list") ? [varKind] : [varKind, `${varKind}_list`];
+  }
+  return null;
+}

package/src/games/profile.ts

@@ -0,0 +1,205 @@
+/**
+ * The GameProfile boundary (docs/PLAN.md §3): everything game-specific lives
+ * behind this interface, in one module per game under games/. The engine and
+ * features never name a game, they read the active profile (games/active.ts)
+ * or the SchemaData built from it (schema/loader.ts).
+ *
+ * CI enforces the boundary: outside packages/server/src/games/ and
+ * packages/vscode/, game-name strings may not appear in source
+ * (scripts/check-game-boundary.mjs).
+ */
+import type { DefRootKey, RefField, SchemaEntry, StructureSpec } from "../schema/types";
+import type { PlaceholderSpec } from "../data/modifierTemplates";
+import type { GuiLayoutQuirks, GuiTextMetrics } from "../gui/layoutEngine";
+import type { SaveSchema } from "../gui/saveSchema";
+
+/**
+ * One "New Content" template: the content of a scaffold, as data, so the writer
+ * (packages/vscode/src/scaffold/) stays game-neutral. Every text field expands
+ * four placeholders: `$PREFIX$` (the mod prefix), `$NAME$` (the key or event id
+ * the user gave), `$KEY$` (`$NAME$` with dots turned into underscores, for
+ * games whose loc keys cannot carry a dot) and `$LANG$` (the loc language).
+ *
+ * Every template must be written from the game's OWN vanilla files: a scaffold
+ * that names a key the game does not know is exactly the silent failure this
+ * command exists to prevent.
+ */
+export interface ScaffoldTemplate {
+  /** Stable kind id, also the quick-pick value ("event", "on_action"). */
+  id: string;
+  /** Quick-pick label including its codicon ("$(zap) Event"). */
+  label: string;
+  /** Quick-pick detail: where the content lands. */
+  detail: string;
+  /** Word for the name prompt ("event id", "decision"). */
+  nameLabel: string;
+  /** Shape `$NAME$` must have: a plain identifier or a `<prefix>.<number>` id. */
+  nameKind: "identifier" | "eventId";
+  /**
+   * Fixed choices for `$NAME$` (the vanilla on_action names to hook), offered
+   * as a quick-pick with a free-text escape instead of a bare input box.
+   */
+  picks?: string[];
+  /** Script file, mod-relative with forward slashes. */
+  scriptPath: string;
+  /** The block written, and appended when the file already exists. */
+  block: string;
+  /** The (expanded) line inside `block` the cursor lands on. */
+  cursorMarker: string;
+  /** Line the script file MUST start with (the event namespace). */
+  requiredHeader?: string;
+  /** Loc file, when the content type needs loc keys. */
+  locPath?: string;
+  /** Loc entry lines (without the `l_<lang>:` header). */
+  locBody?: string;
+}
+
+/**
+ * Data-only identity and conventions of a supported game. Kept separate from
+ * the knowledge tables so clients (the VSCode extension) can import a game's
+ * meta without pulling the bundled schema/data into their bundle.
+ */
+export interface GameMeta {
+  /** Stable id used on the wire (settings.gameId) and for data/<id>/ bundles. */
+  id: string;
+  /** Full display name ("Crusader Kings III"). */
+  name: string;
+  /** Short user-facing prefix for progress titles and messages ("CK3"). */
+  shortName: string;
+  engine: "jomini" | "clausewitz-classic";
+  /** Mod descriptor convention: Paradox-launcher `.mod` file vs `.metadata/metadata.json`. */
+  descriptor: "mod" | "metadata";
+  /** Per-workspace config dir holding schema.json / playset.json overlays. */
+  configDirName: string;
+  /** Game folder under `Documents/Paradox Interactive/` (script_docs logs live in its logs/). */
+  docsFolderName: string;
+  /**
+   * Subfolder of docsFolderName holding the script_docs dumps. Absent =
+   * "logs" (the classic location); newer titles may write to "docs".
+   */
+  scriptDocsSubdir?: string;
+  /**
+   * Console command that dumps the data-type documentation. Absent =
+   * "DumpDataTypes" (CK3's casing); newer Jomini titles use snake_case.
+   * The dump lands under `<Documents>/<docsFolderName>/logs/` regardless of
+   * where script_docs go.
+   */
+  dataTypesCommand?: string;
+  steamAppId: number;
+  /** Whether event files declare `namespace = x` and use `ns.N` event ids. */
+  eventNamespaces: boolean;
+  /**
+   * Subfolder of docsFolderName the ENGINE writes error.log into. Absent =
+   * "logs", which is where both live installs checked (2026-08-12) write it.
+   * Independent of scriptDocsSubdir, which newer titles point at docs/.
+   */
+  errorLogSubdir?: string;
+  /**
+   * The game's default UI font file, relative to the game data dir, embedded by
+   * the GUI editor so its canvas text looks like the game's. Absent = no font
+   * is embedded and the webview falls back to a system serif.
+   */
+  uiFont?: string;
+  /**
+   * In-game-measured text metrics for the game's default GUI font, feeding the
+   * layout engine's text measurer and the editor canvas. Absent = the game is
+   * NOT calibrated: the engine assumes the default table
+   * (gui/measuredMetrics.ts) and the GUI editor refuses to open. Measured via
+   * docs/gui-designer/calibration/probes/.
+   */
+  guiTextMetrics?: GuiTextMetrics;
+  /**
+   * "New Content" templates offered for this game, in quick-pick order. Absent
+   * or empty = no content type has been verified against the game's own files,
+   * and the command says so instead of writing a guess.
+   */
+  scaffolds?: ScaffoldTemplate[];
+  /**
+   * Load-stage folders at the mod root under which all content lives (EU5's
+   * `in_game/` etc.). Schema paths carry the prefix explicitly; this list is
+   * for mod detection. Absent = content sits directly at the mod root.
+   */
+  stageRoots?: string[];
+  /**
+   * The game composes flags from `common/coat_of_arms` definitions over
+   * `gfx/coat_of_arms/{patterns,colored_emblems,textured_emblems}` textures,
+   * in the layout the flag builder renders. Absent = the Flag Builder does
+   * not open for this game.
+   */
+  flagBuilder?: boolean;
+  /**
+   * Database entry-mode prefixes legal on top-level definition keys
+   * (EU5's `REPLACE:key`). The indexer strips a leading `<MODE>:` before
+   * treating the rest as the definition name. Absent = no such syntax.
+   */
+  entryModes?: string[];
+  /**
+   * script_docs dump dialect. Absent = the classic plain-text format
+   * (`name - doc` entries with `----` separators). Newer Jomini titles emit
+   * markdown (`## name`, `**Supported Scopes**`) and per-game modifier shapes:
+   * "masked-block" (`tag:` + indented Mask/Name/Description) or "tag-line"
+   * (`Tag: name, Categories: ...` lines).
+   */
+  scriptDocs?: { format: "classic" | "markdown"; modifiers: "classic" | "masked-block" | "tag-line" };
+  /** External deep-validation tool (the tiger family), when one exists. */
+  tiger?: { binaryName: string; repoSlug: string; confName: string };
+  /**
+   * Suffix for server-side cache filenames under storageDir ("" keeps the
+   * pre-profile names so existing caches survive; non-empty for later games,
+   * e.g. "-vic3", so games sharing one storageDir never collide).
+   */
+  cacheSuffix: string;
+}
+
+/** A game's full knowledge bundle: meta plus the tables the engine consumes. */
+export interface GameProfile extends GameMeta {
+  /** Folder→definition-kind table (see schema/types.ts). */
+  schema: SchemaEntry[];
+  /** Assignment keys whose values reference other definitions. */
+  refFields: RefField[];
+  /** Scalar-value prefixes that reference definitions (`culture:czech`). */
+  prefixRefs: Record<string, string[]>;
+  /** Block-local ref fields (outer key → inner key → kinds). */
+  blockRefFields: Record<string, Record<string, string[]>>;
+  /** Hover provenance labels per definition kind (`_*.info` folder names). */
+  structureSources: Record<string, string>;
+  /**
+   * Block-schema `structure` layer per definition kind, attached to the matching
+   * schema entries at load (schema/loader.ts). A game whose schema table already
+   * carries `structure` on its entries (a hand-curated layer) needs nothing here;
+   * those entries always win.
+   */
+  structures?: Record<string, StructureSpec>;
+  /**
+   * Definition kinds that declare their own root scope in their body, keyed by
+   * kind (scopes/inference.ts). Absent = every kind's root scope comes from the
+   * schema table alone.
+   */
+  defRootKeys?: Record<string, DefRootKey>;
+  /** Templated-modifier placeholder table (data/modifierTemplates.ts). */
+  modifierPlaceholders: Record<string, PlaceholderSpec>;
+  /**
+   * Bundled `[ ... ]` data-function tables (data/<id>/dataTypes.json), when the
+   * game ships one. Shape is data/dataTypes.ts's bundled-JSON shape; typed
+   * loosely here to keep profiles JSON-import-friendly.
+   */
+  bundledDataTypes?: unknown;
+  /** Bundled .gui widget schema (data/<id>/guiSchema.json), when available. */
+  guiSchema?: unknown;
+  /**
+   * In-game-measured layout rule divergences from the engine's defaults
+   * (which are themselves in-game-measured for the default profile). Each
+   * flag documents its probe in gui/layoutEngine.ts's GuiLayoutQuirks.
+   */
+  guiLayoutQuirks?: GuiLayoutQuirks;
+  /**
+   * How this game's save games are read for GUI preview values: the entity
+   * mapping, the meta keys and the shape the streaming reader must expect
+   * (gui/saveSchema.ts). Absent = a save answers the meta-only default rows.
+   */
+  saveSchema?: SaveSchema;
+  /** Trailing provenance note on bundled-wiki token hovers. */
+  wikiNote: string;
+  /** LSP diagnostic `source` label ("ck3-script"). */
+  diagnosticSource: string;
+}

package/src/games/registry.ts

@@ -0,0 +1,27 @@
+/**
+ * Registry of in-repo game profiles. Profiles are not a plugin API (PLAN.md
+ * non-goals): adding a game means adding a games/<id>/ module and registering
+ * it here.
+ */
+import type { GameProfile } from "./profile";
+import { ck3Profile } from "./ck3";
+import { vic3Profile } from "./vic3";
+import { eu5Profile } from "./eu5";
+
+const profiles = new Map<string, GameProfile>([
+  [ck3Profile.id, ck3Profile],
+  [vic3Profile.id, vic3Profile],
+  [eu5Profile.id, eu5Profile],
+]);
+
+export const defaultProfile: GameProfile = ck3Profile;
+
+/** The profile for a wire gameId; unknown/absent ids fall back to the default
+ * (bare LSP clients predating gameId keep working). */
+export function resolveProfile(id: string | null | undefined): GameProfile {
+  return (id && profiles.get(id)) || defaultProfile;
+}
+
+export function allProfiles(): GameProfile[] {
+  return [...profiles.values()];
+}

package/src/games/vic3/index.ts

@@ -0,0 +1,52 @@
+/**
+ * The Victoria 3 game profile (shipped, PLAN-multigame.md M7): schema verified
+ * against a real install, gui widget schema harvested from vanilla, freqs from
+ * the vanilla corpus; engine tokens come from the user's script_docs dumps
+ * (markdown format). No wiki fallback and no structures layer, see below.
+ */
+import type { GameProfile } from "../profile";
+import { vic3Meta } from "./meta";
+import { VIC3_BLOCK_REF_FIELDS, VIC3_PREFIX_REFS, VIC3_REF_FIELDS, VIC3_SCHEMA } from "./schema";
+import { VIC3_STRUCTURES, VIC3_STRUCTURE_SOURCES } from "./structures";
+import { VIC3_SAVE_SCHEMA } from "./saveSchema";
+import GUI_SCHEMA from "../../../data/vic3/guiSchema.json";
+
+export const vic3Profile: GameProfile = {
+  ...vic3Meta,
+  schema: VIC3_SCHEMA,
+  refFields: VIC3_REF_FIELDS,
+  prefixRefs: VIC3_PREFIX_REFS,
+  blockRefFields: VIC3_BLOCK_REF_FIELDS,
+  guiSchema: GUI_SCHEMA,
+  // guiTextMetrics live on the meta (the client reads them too, for the GUI
+  // editor gate and its canvas line height).
+  // Vic3 keeps an authored size on an EMPTY container (px_probe_c C5: the
+  // 150x60 rendered in full, engine warning logged yet applied) where the
+  // default profile measured collapse-to-0 (L25 narrow).
+  guiLayoutQuirks: { emptySizedContainerKept: true },
+  // Structure layer, fully harvested (games/vic3/structures.ts). The 2026-08-01
+  // note here claimed the Vic3 tree had no source for it: wrong. Vic3 ships no
+  // `_*.info`, but it does ship 91 `*.md` docs next to its data, and 71 of them
+  // are `key = value  # doc` listings in the same shape as CK3's `.info` files,
+  // machine-readable after all. Those, cross-checked against real vanilla usage,
+  // are the source.
+  structures: VIC3_STRUCTURES,
+  structureSources: VIC3_STRUCTURE_SOURCES,
+  // Vic3 events carry no `scope` key: the root scope comes from `type`
+  // (measured over vanilla + three workshop mods, 2026-08-15: country_event
+  // 2533, state_event 14, nothing else at a definition's top level). Assuming
+  // CK3's `scope = character` spelling here put EVERY Vic3 event in a character
+  // scope, which demoted every country effect/trigger to "other scope" and sank
+  // it to the bottom of completion, the measured cause of the flat effect-block
+  // ranking. scripted_guis do declare `scope = X`, with no default.
+  defRootKeys: {
+    event: { key: "type", default: "country", values: { country_event: "country", state_event: "state" } },
+    customizable_localization: { key: "type" },
+    scripted_gui: { key: "scope" },
+  },
+  modifierPlaceholders: {},
+  saveSchema: VIC3_SAVE_SCHEMA,
+  // No bundled wiki tokens in the preview cut, so nothing ever renders this.
+  wikiNote: "",
+  diagnosticSource: "vic3-script",
+};

package/src/games/vic3/meta.ts

@@ -0,0 +1,55 @@
+/**
+ * Victoria 3 identity and conventions. Data only — safe for the VSCode
+ * client to import without pulling the knowledge tables into its bundle.
+ */
+import type { GameMeta } from "../profile";
+import { VIC3_SCAFFOLDS } from "./scaffolds";
+
+export const vic3Meta: GameMeta = {
+  id: "vic3",
+  name: "Victoria 3",
+  shortName: "Vic3",
+  engine: "jomini",
+  // Vic3 mods carry .metadata/metadata.json instead of a launcher .mod file.
+  descriptor: "metadata",
+  configDirName: ".vic3modding",
+  docsFolderName: "Victoria 3",
+  // Vic3's `script_docs` writes to Documents/.../docs (like EU5), while
+  // `dump_data_types` writes to logs/data_types — verified on a live install.
+  scriptDocsSubdir: "docs",
+  dataTypesCommand: "dump_data_types",
+  steamAppId: 529340,
+  eventNamespaces: true,
+  scaffolds: VIC3_SCAFFOLDS,
+  // uiFont deliberately absent: this game ships no Gitan (its fonts/ holds
+  // ParadoxVictorian, EBGaramond, NotoSans), and which file `standard_font`
+  // resolves to is unmeasured. The editor embeds none and the metrics below
+  // carry the text boxes.
+  //
+  // Measured in-game 2026-08-09 (px_probe_d/e, 1920x1080 @ 100% GUI scaling;
+  // docs/gui-designer/calibration/vic3-expectations.md). The measured law:
+  // advance(M) = round(0.9 * fontsize), i.e. 14 @15, 15 @17 (the default
+  // size), 27 @30, and line box = 1.3 * fontsize exactly (the game ceils the
+  // box: 20 @15, 39 @30, 23 @17). A base-30 table + roundPerSize reproduces
+  // every measured box EXACTLY: 10xM = 140 @15 / 150 @default / 270 @30,
+  // "M M M M M" = 82, "MMMM MMMM" = 115, 10xi = 40. A bare textbox renders
+  // at fontsize 17.
+  guiTextMetrics: {
+    baseFontsize: 30,
+    lineHeight: 39,
+    glyphs: {
+      M: { adv: 27, ink: 27 },
+      i: { adv: 8, ink: 8 },
+      " ": { adv: 6, ink: 0 },
+    },
+    defaultGlyph: { adv: 18, ink: 16 }, // unmeasured average guess
+    defaultFontsize: 17,
+    roundPerSize: true,
+  },
+  // Vic3's script_docs dumps are markdown (`## name`), with modifiers as
+  // `tag:` blocks carrying Mask/Name/Description lines.
+  scriptDocs: { format: "markdown", modifiers: "masked-block" },
+  tiger: { binaryName: "vic3-tiger", repoSlug: "amtep/tiger", confName: "vic3-tiger.conf" },
+  cacheSuffix: "-vic3",
+  flagBuilder: true,
+};

package/src/games/vic3/saveSchema.ts

@@ -0,0 +1,77 @@
+/**
+ * How a Victoria 3 save is read for GUI preview values.
+ *
+ * A Vic3 save is plain Jomini script (a big campaign runs ~115 MB and 6.5
+ * million lines) and writes its registries in the order the reader needs them:
+ * `meta_data`, `country_manager`, `states`, `character_manager`. The played
+ * country's own entry names its capital, ruler and heir, so those ids are
+ * already known when the later registries go by and one streaming pass answers
+ * everything.
+ */
+import type { BlockNode } from "../../parser";
+import {
+  block,
+  META_MAPPINGS,
+  named,
+  scalar,
+  thousands,
+  type SaveContext,
+  type SaveSchema,
+  type ValueMapping,
+} from "../../gui/saveSchema";
+
+/** `first_name` + `last_name`, each resolved through loc when it is a key. */
+function characterName(ctx: SaveContext, character: BlockNode | undefined): string | undefined {
+  const parts = [scalar(character, "first_name"), scalar(character, "last_name")]
+    .map((p) => named(ctx, p))
+    .filter((p): p is string => !!p);
+  return parts.length ? parts.join(" ") : undefined;
+}
+
+const VIC3_MAPPINGS: ValueMapping[] = [
+  ...META_MAPPINGS,
+  {
+    chains: ["GetPlayer.GetAdjective"],
+    read: (ctx) => (ctx.tag ? ctx.loc(`${ctx.tag}_ADJ`) : undefined),
+  },
+  {
+    // A character's `GetName` and `GetFullName` both render the whole name;
+    // only `GetFirstName` is narrower.
+    chains: ["GetPlayer.GetRuler.GetName", "GetPlayer.GetRuler.GetFullName"],
+    read: (ctx) => characterName(ctx, ctx.ruler),
+  },
+  {
+    chains: ["GetPlayer.GetRuler.GetFirstName"],
+    read: (ctx) => named(ctx, scalar(ctx.ruler, "first_name")),
+  },
+  {
+    chains: ["GetPlayer.GetHeir.GetName"],
+    read: (ctx) => characterName(ctx, ctx.heir),
+  },
+  {
+    chains: ["GetPlayer.GetCapital.GetName"],
+    read: (ctx) => {
+      const region = scalar(ctx.capital, "region");
+      return region ? (ctx.loc(region) ?? region) : undefined;
+    },
+  },
+  {
+    chains: ["GetPlayer.GetGold", "GetPlayer.GetBudget.GetGold"],
+    read: (ctx) => thousands(scalar(block(ctx.country, "budget"), "money")),
+  },
+];
+
+export const VIC3_SAVE_SCHEMA: SaveSchema = {
+  mappings: VIC3_MAPPINGS,
+  registry: {
+    entries: "database",
+    countryBlock: "country_manager",
+    tagKey: "definition",
+    mainKey: "is_main_tag",
+    links: [
+      { slot: "ruler", key: "ruler", block: "character_manager" },
+      { slot: "heir", key: "heir", block: "character_manager" },
+      { slot: "capital", key: "capital", block: "states" },
+    ],
+  },
+};