@px-lsp/protocol 0.1.0 → 0.2.0

package/dist/kinds.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * One kind map, four surfaces.
+ *
+ * Every place the product names a concept - the hover badge, the completion
+ * list icon, the tree leaf, the breadcrumb/outline entry - reads its glyph from
+ * here, so a trigger looks like a trigger everywhere.
+ *
+ * The colour is not a second decision. VS Code paints a completion row from the
+ * `symbolIcon.*Foreground` token of the `CompletionItemKind` we send, and we
+ * cannot override it, so the kind IS the colour. The hover badge reuses that
+ * same token, which is why there is no colour column to keep in sync. Four
+ * groups come out of that, and choosing the kind is choosing the group:
+ *
+ *   purple   asks a question        Method
+ *   orange   makes it happen        Class, Event, Enum, Value
+ *   blue     you stored it          Variable, Field, Interface, EnumMember
+ *   grey     syntax, everything else  all the rest
+ *
+ * Three facts shape the table and are easy to re-break:
+ *
+ *  1. **Codicon aliases collapse.** `symbol-method`, `symbol-function` and
+ *     `symbol-constructor` are one codepoint, so they are one picture. Same for
+ *     `symbol-enum`/`symbol-value`, `symbol-key`/`symbol-text`,
+ *     `symbol-struct`/`symbol-structure`, `symbol-unit`/`symbol-ruler` and
+ *     `symbol-type-parameter`/`symbol-parameter`. Check a proposed mapping
+ *     against codepoints, not against the names. Prefer the canonical name of a
+ *     pair: only it carries the `symbolIcon.*Foreground` rule, so a themed tree
+ *     leaf tints and an alias does not.
+ *  2. **Only `CompletionItemKind` reaches the suggest widget.** 25 values,
+ *     22 distinct pictures after the collapse. A concept that appears in a
+ *     completion list cannot use a glyph from outside that set in the list,
+ *     even though the hover and the tree can draw all 461 codicons.
+ *  3. **Only `SymbolKind` reaches the outline.** Breadcrumbs, the outline,
+ *     sticky scroll and Ctrl+T take an LSP `SymbolKind`, and VS Code draws
+ *     member `X` with the codicon `symbol-<kebab X>`. `symbolKind` names the
+ *     member drawing the same picture as `codicon`, so the breadcrumb bar and
+ *     the hover badge cannot disagree; it is null for a picture no member
+ *     draws. The server resolves the name to the numeric enum.
+ *
+ * `codicon`, `completionKind` and `symbolKind` are separate fields for exactly
+ * that reason. They name the same picture everywhere except two entries:
+ * `texture`, whose `file-media` glyph no completion kind can produce, and
+ * `list`, whose array glyph no *free* completion kind can produce (the colour
+ * has to stay blue, and all four blue kinds are taken), so the suggest widget
+ * alone still draws it as an enum member.
+ *
+ * Uniqueness is promised *within a completion list*, not globally: script, gui
+ * and datafunction completions never appear together, so they may share glyphs.
+ *
+ * No imports: this is shared by the server and the VS Code client.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_KIND_STYLE = void 0;
+exports.kindStyle = kindStyle;
+exports.hasKindStyle = hasKindStyle;
+exports.mappedKinds = mappedKinds;
+/**
+ * The `SymbolKind` member VS Code draws with each picture the table uses. VS
+ * Code renders member `X` as `symbol-<kebab X>`, so this is that rule read
+ * backwards, with the alias pairs resolved to the member owning the codepoint
+ * (`symbol-value` is `symbol-enum`, `symbol-text` is `symbol-key`). A codicon
+ * absent here has no `SymbolKind` at all: there are 26 members against 461
+ * codicons.
+ */
+const SYMBOL_KIND_BY_CODICON = {
+    "symbol-array": "Array",
+    "symbol-class": "Class",
+    "symbol-constant": "Constant",
+    "symbol-enum-member": "EnumMember",
+    "symbol-event": "Event",
+    "symbol-field": "Field",
+    "symbol-interface": "Interface",
+    "symbol-method": "Method",
+    "symbol-module": "Module",
+    "symbol-operator": "Operator",
+    "symbol-property": "Property",
+    "symbol-struct": "Struct",
+    "symbol-text": "Key",
+    "symbol-type-parameter": "TypeParameter",
+    "symbol-value": "Enum",
+    "symbol-variable": "Variable",
+};
+/**
+ * The only completion kinds VS Code tints; the other 15 render in the plain
+ * editor foreground, so their badge emits no span at all.
+ */
+const TINT = {
+    Method: "method",
+    Function: "function",
+    Constructor: "constructor",
+    Class: "class",
+    Enum: "enumerator",
+    Value: "enumerator",
+    Event: "event",
+    Variable: "variable",
+    Field: "field",
+    Interface: "interface",
+    EnumMember: "enumeratorMember",
+};
+/**
+ * `colorFrom` defaults to the completion kind, which is what keeps the badge
+ * and the row the same colour. `on_action` is the one entry that overrides it:
+ * it wants the interface glyph with the orange of the group it belongs to, and
+ * a completion row cannot have both.
+ */
+const c = (codicon, completionKind, colorFrom = completionKind) => ({
+    codicon,
+    completionKind,
+    symbolKind: SYMBOL_KIND_BY_CODICON[codicon] ?? null,
+    color: TINT[colorFrom] ? `var(--vscode-symbolIcon-${TINT[colorFrom]}Foreground)` : null,
+});
+const SCRIPT = {
+    // purple: asks a question.
+    trigger: c("symbol-method", "Method"),
+    scripted_trigger: c("symbol-method", "Method"),
+    datafn: c("symbol-method", "Method"),
+    // orange: makes it happen.
+    effect: c("symbol-event", "Event"),
+    scripted_effect: c("symbol-event", "Event"),
+    event: c("symbol-class", "Class"),
+    decision: c("symbol-class", "Class"),
+    gui_type: c("symbol-class", "Class"),
+    data_type: c("symbol-class", "Class"),
+    on_action: c("symbol-interface", "Interface", "Class"),
+    trait: c("symbol-value", "Value"),
+    // blue: you stored it. A name that resolves to a scope or a stored value.
+    variable: c("symbol-variable", "Variable"),
+    local_variable: c("symbol-variable", "Variable"),
+    global_variable: c("symbol-variable", "Variable"),
+    promote: c("symbol-variable", "Variable"),
+    saved_scope: c("symbol-field", "Field"),
+    event_target: c("symbol-interface", "Interface"),
+    // The four list kinds each get their own picture. `add_to_list` builds a
+    // collection that lives for one effect block and is never saved, so it takes
+    // the array picture; the three `*_variable_list` kinds are entries in
+    // variable storage, split by storage class: the object-attached one keeps
+    // the enum-member picture, the event-chain-local one the plain list, the
+    // game-global one the globe.
+    // All four stay on `EnumMember`: the four blue completion kinds are already
+    // spoken for by variable, saved_scope and event_target, so the suggest widget
+    // draws every list as one blue enum-member row; the split shows in the hover
+    // badge and the tree. Of the four pictures only `symbol-enum-member` carries
+    // a `symbolIcon` colour rule, so the other three render tree leaves in the
+    // plain icon foreground while their badges stay blue (the map emits the
+    // colour); `list-unordered` and `globe` are pictures no SymbolKind draws, so
+    // those two fall back to Object in symbol lists.
+    list: c("symbol-array", "EnumMember"),
+    variable_list: c("symbol-enum-member", "EnumMember"),
+    local_variable_list: c("list-unordered", "EnumMember"),
+    global_variable_list: c("globe", "EnumMember"),
+    // grey: syntax and everything else.
+    scope_word: c("symbol-constant", "Constant"),
+    structure_key: c("symbol-struct", "Struct"),
+    descriptor_field: c("symbol-struct", "Struct"),
+    keyword: c("symbol-keyword", "Keyword"),
+    modifier: c("symbol-property", "Property"),
+    scripted_modifier: c("symbol-property", "Property"),
+    gui_property: c("symbol-property", "Property"),
+    script_value: c("symbol-operator", "Operator"),
+    define: c("symbol-unit", "Unit"),
+    namespace: c("symbol-module", "Module"),
+    loc_key: c("symbol-text", "Text"),
+    macro_param: c("symbol-type-parameter", "TypeParameter"),
+    text_format: c("symbol-color", "Color"),
+    gui_enum_value: c("symbol-constant", "Constant"),
+    format_suffix: c("symbol-constant", "Constant"),
+    gui_template: c("symbol-snippet", "Snippet"),
+    // The picture-frame glyph no completion kind can draw: the hover and the tree
+    // get `file-media`, the completion row falls back to the plain file glyph.
+    texture: c("file-media", "File"),
+};
+/** Anything the map does not name: a definition we have no opinion about. */
+exports.DEFAULT_KIND_STYLE = c("go-to-file", "Reference");
+/** Glyph, completion kind and badge colour for a kind name. Never throws. */
+function kindStyle(kind) {
+    return SCRIPT[kind] ?? exports.DEFAULT_KIND_STYLE;
+}
+/** True when the map has an opinion, i.e. the kind is not falling through. */
+function hasKindStyle(kind) {
+    return Object.prototype.hasOwnProperty.call(SCRIPT, kind);
+}
+/** Every mapped kind, for the coverage test that keeps this table honest. */
+function mappedKinds() {
+    return Object.keys(SCRIPT);
+}

package/dist/protocol.d.ts

@@ -17,6 +17,16 @@ export interface ParadoxSettings {
     locLanguage: string;
     /** Show inferred scope after scope-changing block openers (off by default). */
     scopeInlayHints: boolean;
+    /**
+     * How much a hover shows. `standard` applies every cap in the design;
+     * `compact` drops prose and examples; `full` lifts the example cap and shows
+     * every distinct meaning.
+     */
+    hoverDetail?: "compact" | "standard" | "full";
+    /** Custom era calendar (total-conversion mods): how script dates display in
+     * game. Absent = no calendar features. Shape: calendar.ts `CalendarSetting`;
+     * the server sanitizes it on intake, so clients may pass raw JSON. */
+    calendar?: import("./calendar").CalendarSetting;
     /** Our diagnostic codes to suppress everywhere. */
     diagnosticsIgnore: string[];
     /** Glob patterns (workspace-relative paths) whose diagnostics are suppressed. */
@@ -54,6 +64,25 @@ export interface ParadoxClientCapabilities {
      * registers one whenever the client supports dynamic registration.
      */
     ownFileWatcher?: boolean;
+    /**
+     * The client's hover renderer navigates `file:` links, so provenance lines
+     * ("where is this defined") may be markdown links. Default false: the same
+     * `file.txt:12` label is rendered as plain text, which reads correctly in a
+     * client that would otherwise show a dead link.
+     *
+     * Note that `textDocument.completion.completionItem.snippetSupport` — the
+     * other axis an embedder should declare — is a STANDARD LSP capability, not
+     * one of these: send it in the initialize params, not here.
+     */
+    fileLinks?: boolean;
+    /**
+     * The client renders `$(codicon)` theme icons in hover markdown, i.e. it sets
+     * `supportThemeIcons` on the MarkdownString. Default false, and the default
+     * matters: a client without it prints the literal text `$(symbol-method)`,
+     * which is worse than the plain `■` it would otherwise get. Implies
+     * {@link ParadoxClientCapabilities.hoverHtml} is respected for colour.
+     */
+    hoverIcons?: boolean;
 }
 /** initializationOptions passed at LanguageClient start. All fields optional:
  * the server has fail-soft fallbacks for bare clients. */
@@ -66,9 +95,9 @@ export interface ParadoxInitOptions {
     /**
      * @deprecated Send {@link ParadoxInitOptions.client} instead. `true` is an
      * alias for `{ hoverHtml: true, commands: <every id in clientCommands>,
-     * ownFileWatcher: true }` (what the VSCode extension declared before the
-     * capabilities object existed); false/absent means all-off. Ignored when
-     * `client` is present.
+     * ownFileWatcher: true, fileLinks: true }` plus snippet support (what the
+     * VSCode extension declared before the capabilities object existed);
+     * false/absent means all-off. Ignored when `client` is present.
      */
     clientCommands?: boolean;
     /**
@@ -100,6 +129,7 @@ export declare const clientCommands: {
     readonly editLocalization: "px.editLocalization";
     readonly openLocalizationSideBySide: "px.openLocalizationSideBySide";
     readonly showReferences: "px.showReferences";
+    readonly showExamplesWiki: "px.showExamplesWiki";
 };
 /** Every id in {@link clientCommands}: what a fully capable client registers. */
 export declare const allClientCommandIds: string[];
@@ -143,6 +173,10 @@ export interface StatusPayload {
      * (data/<gameId>/script_docs) rather than the user's own dump. */
     tokensFromBundledDumps?: boolean;
     definitions: number;
+    /** Tokens the bundled wiki added that script_docs did not have. The wiki is
+     * merged even when the user has their own dump, but its real contribution is
+     * usage examples; the extra NAMES are mostly deprecated API. */
+    tokensWikiOnly?: number;
     /** True while a (re)scan is running. */
     indexing: boolean;
 }
@@ -374,6 +408,148 @@ export interface EventDetail {
     options: EventOptionInfo[];
     refs: EventRefInfo[];
 }
+/**
+ * Request: the searchable catalog behind the Examples Wiki;
+ * `null` -> {@link ExampleWikiIndex}.
+ *
+ * One compact row per name the server knows about, so a client can filter and
+ * rank the whole vocabulary without asking again. Everything expensive (the
+ * full documentation, the usage block, the vanilla sites) is left to
+ * {@link exampleWikiEntryRequest}.
+ */
+export declare const exampleWikiRequest = "paradox/exampleWiki";
+/**
+ * What an Examples Wiki row is. The first four are engine tokens from
+ * script_docs or the wiki tables; the next three are `[ ... ]` datafunctions:
+ * a global (`GetPlayer`), a member of a data type (`Character.GetName`), and
+ * a data type itself (`Character`). The next seven are the variable and list
+ * names the definition index found in the indexed script itself, one kind per
+ * storage class ({@link exampleWikiVariableKinds}). The last two are the script
+ * grammar the game documents nowhere ({@link exampleWikiVocabularyKinds}): the
+ * glue keywords (`limit`, `NOT`, `base`) and the scope words (`root`, `prev`).
+ */
+export type ExampleWikiKind = "trigger" | "effect" | "event_target" | "modifier" | "datafn_global" | "datafn_member" | "data_type" | "keyword" | "scope_word" | "variable" | "local_variable" | "global_variable" | "variable_list" | "local_variable_list" | "global_variable_list" | "list";
+/** The {@link ExampleWikiKind}s whose rows come from the definition index. */
+export declare const exampleWikiVariableKinds: ExampleWikiKind[];
+/**
+ * The {@link ExampleWikiKind}s whose rows are script grammar rather than a
+ * name from a dump or an index. One filter chip covers both.
+ */
+export declare const exampleWikiVocabularyKinds: ExampleWikiKind[];
+export interface ExampleWikiEntry {
+    /** Display and lookup name; a member carries its owner (`Character.GetName`). */
+    name: string;
+    kind: ExampleWikiKind;
+    /** Owning data type of a member row; absent on every other kind. */
+    owner?: string;
+    /** First sentence of the documentation, capped; empty when undocumented. */
+    shortDoc: string;
+    /** Times vanilla uses the name. 0 means "not counted", not "never used". */
+    count: number;
+}
+export interface ExampleWikiIndex {
+    /** Every row, most-used first. */
+    entries: ExampleWikiEntry[];
+    /** Plain sentences naming where the rows came from, for an About line. */
+    sources: string[];
+    /** True when the rows do NOT come from the user's own script_docs dump, so
+     *  a client can suggest running `script_docs` in the game console. */
+    needsScriptDocs: boolean;
+}
+/**
+ * Request: everything the toolkit knows about ONE Examples Wiki row;
+ * {@link ExampleWikiEntryParams} -> {@link ExampleWikiDetail} | null.
+ *
+ * `null` means the name is not in the catalog. Vanilla example sites are
+ * searched on demand and come back as absolute paths, so a client can open
+ * the file at the line without resolving anything itself.
+ */
+export declare const exampleWikiEntryRequest = "paradox/exampleWikiEntry";
+export interface ExampleWikiEntryParams {
+    name: string;
+    kind: ExampleWikiKind;
+}
+/** One place in the game or mod files that uses the name. */
+export interface ExampleWikiSite {
+    /** The line as written, trimmed and capped. */
+    text: string;
+    /** Absolute path. */
+    file: string;
+    /** 1-based line number. */
+    line: number;
+    /**
+     * The lines around the site as written, dedented and capped, with the `line`
+     * line among them. Absent when the file could not be read.
+     */
+    context?: string[];
+    /** 1-based line number of `context[0]`; absent with `context`. */
+    contextStart?: number;
+    /** What the site does with the name ("set", "read"); absent when it only uses it. */
+    label?: string;
+}
+export interface ExampleWikiDetail {
+    name: string;
+    kind: ExampleWikiKind;
+    owner?: string;
+    count: number;
+    /** Full documentation prose; empty when nothing documents the name. */
+    doc: string;
+    /** Scopes an engine token works in; empty when unknown. */
+    scopes: string[];
+    /** The token's remaining script_docs metadata lines, verbatim. */
+    traits?: string;
+    /** The `usage:` example block from script_docs or the wiki, verbatim. */
+    usage?: string;
+    /** Datafunction return type; absent when unknown. */
+    ret?: string;
+    /** Datafunction argument types, when the dump recorded them. */
+    args?: string[];
+    /** A datafunction is either read like a field or called with parentheses. */
+    callKind?: "promote" | "function";
+    /** Literal arguments vanilla passes, most used first. */
+    literals: string[];
+    /** Literals found before the list was capped. */
+    literalsTotal: number;
+    /** Members of a data type, or nothing on other kinds. */
+    members: string[];
+    membersTotal: number;
+    /** Datafunctions that return this data type. */
+    producers: string[];
+    producersTotal: number;
+    /** What a variable holds, in words ("character", "list of title", "unknown"). */
+    valueType?: string;
+    /** Top-level definitions a variable is set inside, most sites first. */
+    containers?: string[];
+    /** Containers found before the list was capped. */
+    containersTotal?: number;
+    /** Vanilla uses, capped; empty when the search found none. */
+    examples: ExampleWikiSite[];
+    /** Why the example list looks the way it does, in one sentence. */
+    examplesNote?: string;
+    /**
+     * What can be written FROM each scope this token produces, one entry per
+     * `output: S` scope. Present only on a token that declares one; every list
+     * is derived from the declared scopes of the other catalog rows.
+     */
+    fromScope?: ExampleWikiFromScope[];
+    /** Where the facts above come from, in one sentence. */
+    provenance: string;
+}
+/** Names usable once a token has moved the scope to {@link scope}, most used
+ *  first. Each list is capped; the `*Total` is what was found before the cap. */
+export interface ExampleWikiFromScope {
+    /** The produced scope word, as the game's own docs write it ("faith"). */
+    scope: string;
+    /** Triggers whose declared scopes include this one. */
+    triggers: string[];
+    triggersTotal: number;
+    /** Effects whose declared scopes include this one. */
+    effects: string[];
+    effectsTotal: number;
+    /** Event targets that take this scope as input. */
+    targets: string[];
+    targetsTotal: number;
+}
 /** Request: GUI widget tree for a .gui document; {@link GuiTreeParams} -> {@link GuiTree}. */
 export declare const guiTreeRequest = "paradox/guiTree";
 export interface GuiTreeParams {
@@ -404,7 +580,7 @@ export interface GuiTree {
 /**
  * Request: rendered GUI layout for a .gui document;
  * {@link GuiLayoutParams} -> {@link GuiLayoutResult}. Rectangles come from
- * the measured layout engine (docs/gui-designer/calibration/spec.md), with
+ * the measured layout engine (docs/gui-designer/spec.md), with
  * templates/types resolved against the vanilla + mod gui tree.
  */
 export declare const guiLayoutRequest = "paradox/guiLayout";

package/dist/protocol.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scopeAtRequest = exports.dependenciesRequest = exports.eventValueOptionsRequest = exports.EVENT_VOCABULARY_MAX_VALUES = exports.EVENT_VOCABULARY_MAX_TOKENS = exports.eventVocabularyRequest = exports.eventBannerRequest = exports.eventGraphRequest = exports.guiWidgetEditRequest = exports.guiSourceEditRequest = exports.guiSaveValuesRequest = exports.GUI_PREVIEW_MAX = exports.guiPreviewRequest = exports.guiVocabularyRequest = exports.guiDependenciesRequest = exports.guiWidgetInfoRequest = exports.guiLayoutRequest = exports.guiTreeRequest = exports.eventDetailRequest = exports.overridesRequest = exports.locCoverageRequest = exports.modOverviewRequest = exports.progressNotification = exports.indexChangedNotification = exports.statusNotification = exports.lookupLocRequest = exports.indexStatsRequest = exports.reloadDocsRequest = exports.modFileChangedNotification = exports.configChangedNotification = exports.allClientCommandIds = exports.clientCommands = void 0;
+exports.scopeAtRequest = exports.dependenciesRequest = exports.eventValueOptionsRequest = exports.EVENT_VOCABULARY_MAX_VALUES = exports.EVENT_VOCABULARY_MAX_TOKENS = exports.eventVocabularyRequest = exports.eventBannerRequest = exports.eventGraphRequest = exports.guiWidgetEditRequest = exports.guiSourceEditRequest = exports.guiSaveValuesRequest = exports.GUI_PREVIEW_MAX = exports.guiPreviewRequest = exports.guiVocabularyRequest = exports.guiDependenciesRequest = exports.guiWidgetInfoRequest = exports.guiLayoutRequest = exports.guiTreeRequest = exports.exampleWikiEntryRequest = exports.exampleWikiVocabularyKinds = exports.exampleWikiVariableKinds = exports.exampleWikiRequest = exports.eventDetailRequest = exports.overridesRequest = exports.locCoverageRequest = exports.modOverviewRequest = exports.progressNotification = exports.indexChangedNotification = exports.statusNotification = exports.lookupLocRequest = exports.indexStatsRequest = exports.reloadDocsRequest = exports.modFileChangedNotification = exports.configChangedNotification = exports.allClientCommandIds = exports.clientCommands = void 0;
 // ---- client command ids ----------------------------------------------------
 /**
  * Client commands the server references in code actions and hover links (part
@@ -14,6 +14,7 @@ exports.clientCommands = {
     editLocalization: "px.editLocalization",
     openLocalizationSideBySide: "px.openLocalizationSideBySide",
     showReferences: "px.showReferences",
+    showExamplesWiki: "px.showExamplesWiki",
 };
 /** Every id in {@link clientCommands}: what a fully capable client registers. */
 exports.allClientCommandIds = Object.values(exports.clientCommands);
@@ -48,12 +49,46 @@ exports.locCoverageRequest = "paradox/locCoverage";
 exports.overridesRequest = "paradox/overrides";
 /** Request: full event detail for the graph inspector; {@link EventDetailParams} -> {@link EventDetail} | null. */
 exports.eventDetailRequest = "paradox/eventDetail";
+/**
+ * Request: the searchable catalog behind the Examples Wiki;
+ * `null` -> {@link ExampleWikiIndex}.
+ *
+ * One compact row per name the server knows about, so a client can filter and
+ * rank the whole vocabulary without asking again. Everything expensive (the
+ * full documentation, the usage block, the vanilla sites) is left to
+ * {@link exampleWikiEntryRequest}.
+ */
+exports.exampleWikiRequest = "paradox/exampleWiki";
+/** The {@link ExampleWikiKind}s whose rows come from the definition index. */
+exports.exampleWikiVariableKinds = [
+    "variable",
+    "local_variable",
+    "global_variable",
+    "variable_list",
+    "local_variable_list",
+    "global_variable_list",
+    "list",
+];
+/**
+ * The {@link ExampleWikiKind}s whose rows are script grammar rather than a
+ * name from a dump or an index. One filter chip covers both.
+ */
+exports.exampleWikiVocabularyKinds = ["keyword", "scope_word"];
+/**
+ * Request: everything the toolkit knows about ONE Examples Wiki row;
+ * {@link ExampleWikiEntryParams} -> {@link ExampleWikiDetail} | null.
+ *
+ * `null` means the name is not in the catalog. Vanilla example sites are
+ * searched on demand and come back as absolute paths, so a client can open
+ * the file at the line without resolving anything itself.
+ */
+exports.exampleWikiEntryRequest = "paradox/exampleWikiEntry";
 /** Request: GUI widget tree for a .gui document; {@link GuiTreeParams} -> {@link GuiTree}. */
 exports.guiTreeRequest = "paradox/guiTree";
 /**
  * Request: rendered GUI layout for a .gui document;
  * {@link GuiLayoutParams} -> {@link GuiLayoutResult}. Rectangles come from
- * the measured layout engine (docs/gui-designer/calibration/spec.md), with
+ * the measured layout engine (docs/gui-designer/spec.md), with
  * templates/types resolved against the vanilla + mod gui tree.
  */
 exports.guiLayoutRequest = "paradox/guiLayout";

package/dist/workshopMeta.d.ts

@@ -0,0 +1,42 @@
+/** Title/description pair of one Workshop language. Absent field = not translated. */
+export interface WorkshopTranslation {
+    title?: string;
+    description?: string;
+}
+/** The fields of `workshop.json` this toolkit reads or writes. */
+export interface WorkshopMeta {
+    /** Workshop item id (decimal string), for the games whose descriptor has no field for it. */
+    publishedFileId?: string;
+    /** The item's description in the default language, BBCode as Steam renders it. */
+    description?: string;
+    /** Keyed by Steam API language code (`german`, `schinese`, ...), never the default language. */
+    translations?: Record<string, WorkshopTranslation>;
+}
+/** Mod-root-relative path of the record, forward slashes. */
+export declare function workshopMetaRelPath(configDirName: string): string;
+/** The parsed `<dir>/<configDir>/workshop.json`, or null when absent/unreadable. */
+export declare function readWorkshopMeta(dir: string, configDirName: string): WorkshopMeta | null;
+/**
+ * Merge `patch` into the record and write it back. Unknown keys of the file
+ * survive; a patch key set to `undefined` is left as it was. `translations`
+ * replaces as a whole (the caller edits the full map).
+ */
+export declare function upsertWorkshopMeta(dir: string, configDirName: string, patch: WorkshopMeta): void;
+/**
+ * The languages the Workshop accepts item text in: Steam's API language codes
+ * with their English names, in Steam's documented order.
+ * https://partner.steamgames.com/doc/store/localization/languages
+ */
+export declare const STEAM_LANGUAGES: readonly {
+    api: string;
+    label: string;
+}[];
+/** English name of a Steam API language code; the code itself when unknown. */
+export declare function steamLanguageLabel(api: string): string;
+/**
+ * Steam API language code for a Paradox localization folder language
+ * (`translationCore.ts` LOC_LANGUAGES), or null when Steam has no counterpart.
+ * The two vocabularies differ where Steam's codes predate its own store pages
+ * (`koreana`, `schinese`).
+ */
+export declare function steamLanguageForLoc(locLanguage: string): string | null;