@px-lsp/protocol 0.1.0 → 0.2.0

package/dist/workshopMeta.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STEAM_LANGUAGES = void 0;
+exports.workshopMetaRelPath = workshopMetaRelPath;
+exports.readWorkshopMeta = readWorkshopMeta;
+exports.upsertWorkshopMeta = upsertWorkshopMeta;
+exports.steamLanguageLabel = steamLanguageLabel;
+exports.steamLanguageForLoc = steamLanguageForLoc;
+/**
+ * The mod's local Workshop record: `<mod>/<configDir>/workshop.json`. It holds
+ * what the game's own descriptor has no field for - the item's description and
+ * its per-language translations (title + description shown to Workshop
+ * visitors browsing Steam in that language), plus the published id for the
+ * `.metadata` games (launcher-`.mod` games keep the id in `remote_file_id`).
+ *
+ * The local file is the canonical copy once the user manages the item from the
+ * toolkit: uploads read from here, and "fetch" pulls the live values down into
+ * it. Reads and writes are merge-preserving: keys this version does not know
+ * survive a round trip.
+ *
+ * No `vscode` imports here: this module is unit-tested in plain Node.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Mod-root-relative path of the record, forward slashes. */
+function workshopMetaRelPath(configDirName) {
+    return `${configDirName}/workshop.json`;
+}
+/** The parsed `<dir>/<configDir>/workshop.json`, or null when absent/unreadable. */
+function readWorkshopMeta(dir, configDirName) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(path.join(dir, configDirName, "workshop.json"), "utf8"));
+        if (typeof raw !== "object" || raw === null)
+            return null;
+        return raw;
+    }
+    catch {
+        return 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).
+ */
+function upsertWorkshopMeta(dir, configDirName, patch) {
+    const file = path.join(dir, configDirName, "workshop.json");
+    const current = (readWorkshopMeta(dir, configDirName) ?? {});
+    for (const [key, value] of Object.entries(patch)) {
+        if (value !== undefined)
+            current[key] = value;
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(current, null, 2) + "\n", "utf8");
+}
+/**
+ * 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
+ */
+exports.STEAM_LANGUAGES = [
+    { api: "arabic", label: "Arabic" },
+    { api: "bulgarian", label: "Bulgarian" },
+    { api: "schinese", label: "Chinese (Simplified)" },
+    { api: "tchinese", label: "Chinese (Traditional)" },
+    { api: "czech", label: "Czech" },
+    { api: "danish", label: "Danish" },
+    { api: "dutch", label: "Dutch" },
+    { api: "english", label: "English" },
+    { api: "finnish", label: "Finnish" },
+    { api: "french", label: "French" },
+    { api: "german", label: "German" },
+    { api: "greek", label: "Greek" },
+    { api: "hungarian", label: "Hungarian" },
+    { api: "indonesian", label: "Indonesian" },
+    { api: "italian", label: "Italian" },
+    { api: "japanese", label: "Japanese" },
+    { api: "koreana", label: "Korean" },
+    { api: "norwegian", label: "Norwegian" },
+    { api: "polish", label: "Polish" },
+    { api: "portuguese", label: "Portuguese" },
+    { api: "brazilian", label: "Portuguese (Brazil)" },
+    { api: "romanian", label: "Romanian" },
+    { api: "russian", label: "Russian" },
+    { api: "spanish", label: "Spanish (Spain)" },
+    { api: "latam", label: "Spanish (Latin America)" },
+    { api: "swedish", label: "Swedish" },
+    { api: "thai", label: "Thai" },
+    { api: "turkish", label: "Turkish" },
+    { api: "ukrainian", label: "Ukrainian" },
+    { api: "vietnamese", label: "Vietnamese" },
+];
+/** English name of a Steam API language code; the code itself when unknown. */
+function steamLanguageLabel(api) {
+    return exports.STEAM_LANGUAGES.find((l) => l.api === api)?.label ?? api;
+}
+/**
+ * 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`).
+ */
+function steamLanguageForLoc(locLanguage) {
+    const map = {
+        english: "english",
+        french: "french",
+        german: "german",
+        spanish: "spanish",
+        russian: "russian",
+        korean: "koreana",
+        simp_chinese: "schinese",
+        japanese: "japanese",
+        polish: "polish",
+        braz_por: "brazilian",
+        turkish: "turkish",
+    };
+    return map[locLanguage] ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@px-lsp/protocol",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "GPL-3.0-or-later",
   "description": "Wire contract (custom LSP requests/notifications, settings types) and shared helpers for the px-lsp language server and its clients.",
   "keywords": [

package/src/arrays.ts

@@ -1,16 +1,16 @@
-/** Array helpers shared by the server and the client. */
-
-/**
- * Append every element of `source` to `target`.
- *
- * `target.push(...source)` passes one argument per element and throws
- * `RangeError: Maximum call stack size exceeded` past ~125k elements (measured,
- * node 24, default stack). On the index paths that is a size-triggered crash:
- * one engine/vanilla root already carries ~460k definitions and one generated
- * mod file can carry six figures on its own. The loop has no ceiling and
- * measures the same as the spread (2M elements appended in 10k pieces: 23 ms
- * loop vs 22 ms spread; as one 500k piece: 5.5 ms loop vs 9.6 ms spread).
- */
-export function pushAll<T>(target: T[], source: readonly T[]): void {
-  for (let i = 0; i < source.length; i++) target.push(source[i]);
-}
+/** Array helpers shared by the server and the client. */
+
+/**
+ * Append every element of `source` to `target`.
+ *
+ * `target.push(...source)` passes one argument per element and throws
+ * `RangeError: Maximum call stack size exceeded` past ~125k elements (measured,
+ * node 24, default stack). On the index paths that is a size-triggered crash:
+ * one engine/vanilla root already carries ~460k definitions and one generated
+ * mod file can carry six figures on its own. The loop has no ceiling and
+ * measures the same as the spread (2M elements appended in 10k pieces: 23 ms
+ * loop vs 22 ms spread; as one 500k piece: 5.5 ms loop vs 9.6 ms spread).
+ */
+export function pushAll<T>(target: T[], source: readonly T[]): void {
+  for (let i = 0; i < source.length; i++) target.push(source[i]);
+}

package/src/calendar.ts

@@ -0,0 +1,184 @@
+/**
+ * Custom calendar display: total-conversion mods (AGoT, LotR, Hegemonia...)
+ * keep script dates on the engine's single increasing year axis but *display*
+ * them on their own era system, e.g. epoch 4000 means script year 3000 shows
+ * as "1000 BC" and 4000 as "1 AD". The mapping cannot be detected from mod
+ * files, so the mod declares it once in `px.calendar` (workspace settings,
+ * committed with the mod).
+ *
+ * Pure logic, no `vscode` imports: shared by the language server (inlay hints,
+ * hover) and the extension (the Insert Date command), unit-tested in plain
+ * Node.
+ */
+
+export interface CalendarMonth {
+  /** Display name ("March", "Narvinye"). */
+  name: string;
+  /** Day count; the engine has no leap years, so one number per month. */
+  days: number;
+}
+
+export interface CalendarSetting {
+  /** Script year displayed as year 1 of the `after` era (no year zero). */
+  epoch: number;
+  /** Era label for script years >= epoch ("AD", "TA"...). */
+  after: string;
+  /** Era label for script years < epoch ("BC"). Omitted = single-era
+   * calendar: years before the epoch get no display form. */
+  before?: string;
+  /** Custom month names and day counts, first month first. Omitted = the
+   * standard 12 months (Feb 28: the engine has no leap years). */
+  months?: CalendarMonth[];
+}
+
+const DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+export const GREGORIAN_MONTHS: CalendarMonth[] = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December",
+].map((name, i) => ({ name, days: DAYS[i] }));
+
+export function monthsOf(cal: CalendarSetting): CalendarMonth[] {
+  return cal.months ?? GREGORIAN_MONTHS;
+}
+
+/**
+ * Validate a calendar straight out of JSON settings (any client, any hand-
+ * edited settings file). Returns a clean copy, or undefined when the value is
+ * not a usable calendar - features then behave as if none was configured.
+ */
+export function sanitizeCalendar(raw: unknown): CalendarSetting | undefined {
+  if (typeof raw !== "object" || raw === null) return undefined;
+  const o = raw as Record<string, unknown>;
+  const epoch = o.epoch;
+  const after = o.after;
+  if (typeof epoch !== "number" || !Number.isInteger(epoch) || epoch < 1) return undefined;
+  if (typeof after !== "string" || after.trim() === "") return undefined;
+  const cal: CalendarSetting = { epoch, after: after.trim() };
+  if (typeof o.before === "string" && o.before.trim() !== "") cal.before = o.before.trim();
+  // Typed input picks the era by its label and the month by its name, so a
+  // collision would resolve silently to the wrong one: not a usable calendar.
+  if (cal.before && cal.before.toLowerCase() === cal.after.toLowerCase()) return undefined;
+  if (Array.isArray(o.months) && o.months.length > 0) {
+    const months: CalendarMonth[] = [];
+    const seen = new Set<string>();
+    for (const m of o.months) {
+      if (typeof m !== "object" || m === null) return undefined;
+      const { name, days } = m as Record<string, unknown>;
+      if (typeof name !== "string" || name.trim() === "") return undefined;
+      if (typeof days !== "number" || !Number.isInteger(days) || days < 1 || days > 999) return undefined;
+      const key = name.trim().toLowerCase();
+      if (seen.has(key)) return undefined;
+      seen.add(key);
+      months.push({ name: name.trim(), days });
+    }
+    cal.months = months;
+  }
+  return cal;
+}
+
+/** A script-file date token (`3000.1.1`), or null when the text is not one. */
+export function parseScriptDate(text: string): { y: number; m: number; d: number } | null {
+  const match = /^(\d{1,5})\.(\d{1,2})\.(\d{1,2})$/.exec(text);
+  if (!match) return null;
+  return { y: Number(match[1]), m: Number(match[2]), d: Number(match[3]) };
+}
+
+/** Month/day within the calendar's bounds (year just has to be positive). */
+export function isValidScriptDate(cal: CalendarSetting, y: number, m: number, d: number): boolean {
+  const months = monthsOf(cal);
+  return y >= 1 && m >= 1 && m <= months.length && d >= 1 && d <= months[m - 1].days;
+}
+
+/** Era-mapped year: "1000 BC". Null for pre-epoch years of a single-era calendar. */
+export function displayYear(cal: CalendarSetting, y: number): string | null {
+  if (y >= cal.epoch) return `${y - cal.epoch + 1} ${cal.after}`;
+  return cal.before ? `${cal.epoch - y} ${cal.before}` : null;
+}
+
+/**
+ * Full display form of a script date: "1000 BC" for the year's first day
+ * (how start dates read in game), "15 March 1000 BC" otherwise. Null when the
+ * date does not fit the calendar.
+ */
+export function displayDate(cal: CalendarSetting, y: number, m: number, d: number): string | null {
+  if (!isValidScriptDate(cal, y, m, d)) return null;
+  const year = displayYear(cal, y);
+  if (!year) return null;
+  if (m === 1 && d === 1) return year;
+  return `${d} ${monthsOf(cal)[m - 1].name} ${year}`;
+}
+
+export type ConvertResult = { ok: true; script: string; display: string } | { ok: false; error: string };
+
+/** Case-insensitive month lookup: exact name, else unique prefix. */
+function monthByName(cal: CalendarSetting, text: string): number | null {
+  const needle = text.toLowerCase();
+  const months = monthsOf(cal);
+  const exact = months.findIndex((m) => m.name.toLowerCase() === needle);
+  if (exact >= 0) return exact + 1;
+  const prefixed = months
+    .map((m, i) => ({ m, i }))
+    .filter(({ m }) => m.name.toLowerCase().startsWith(needle));
+  return prefixed.length === 1 ? prefixed[0].i + 1 : null;
+}
+
+/**
+ * A display-calendar date typed by the user -> the script date the file needs.
+ * Grammar: `YEAR [ERA] [MONTH [DAY]]`, e.g. "1000 BC", "1000 BC March 15",
+ * "1000 BC 3 15", "1 AD", "500" (era defaults to `after`). MONTH is a number
+ * or a month name (unique prefix is enough).
+ */
+export function convertDisplayInput(cal: CalendarSetting, input: string): ConvertResult {
+  const words = input.trim().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return { ok: false, error: "type a year, e.g. 1000 " + (cal.before ?? cal.after) };
+  if (!/^\d{1,5}$/.test(words[0])) return { ok: false, error: `"${words[0]}" is not a year` };
+  const year = Number(words[0]);
+  let rest = words.slice(1);
+
+  let era = cal.after;
+  if (rest.length > 0) {
+    const w = rest[0].toLowerCase();
+    if (w === cal.after.toLowerCase()) {
+      rest = rest.slice(1);
+    } else if (cal.before && w === cal.before.toLowerCase()) {
+      era = cal.before;
+      rest = rest.slice(1);
+    }
+  }
+
+  let m = 1;
+  let d = 1;
+  if (rest.length > 0) {
+    const month = /^\d{1,2}$/.test(rest[0]) ? Number(rest[0]) : monthByName(cal, rest[0]);
+    if (month === null) return { ok: false, error: `"${rest[0]}" is not a month of this calendar` };
+    m = month;
+    rest = rest.slice(1);
+  }
+  if (rest.length > 0) {
+    if (!/^\d{1,3}$/.test(rest[0])) return { ok: false, error: `"${rest[0]}" is not a day` };
+    d = Number(rest[0]);
+    rest = rest.slice(1);
+  }
+  if (rest.length > 0) return { ok: false, error: `unexpected "${rest.join(" ")}"` };
+
+  if (year < 1) return { ok: false, error: "years start at 1 (no year zero)" };
+  const y = era === cal.after ? year + cal.epoch - 1 : cal.epoch - year;
+  if (y < 1) return { ok: false, error: `${year} ${era} is before script year 1 (epoch ${cal.epoch})` };
+  if (!isValidScriptDate(cal, y, m, d)) {
+    const months = monthsOf(cal);
+    return m >= 1 && m <= months.length
+      ? { ok: false, error: `${months[m - 1].name} has ${months[m - 1].days} days` }
+      : { ok: false, error: `this calendar has ${months.length} months` };
+  }
+  return { ok: true, script: `${y}.${m}.${d}`, display: displayDate(cal, y, m, d)! };
+}

package/src/calendarLoc.ts

@@ -0,0 +1,166 @@
+/**
+ * Generate the GAME-SIDE localization for a `px.calendar` display calendar:
+ * the era-math datafunction keys plus the `localization/replace/` overrides
+ * of the engine's date-format and month-name keys. This is the mirror image
+ * of calendar.ts: that file teaches the EDITOR the mapping, this one writes
+ * the mapping into the mod so the GAME displays it (the AGoT/LotR technique).
+ *
+ * Pure logic, no `vscode` imports; the extension command writes the returned
+ * files (adding the BOM) and per-game key names come in via `CalendarLocSpec`
+ * from the GameProfile, so no game knowledge lives here.
+ */
+import type { CalendarSetting } from "./calendar";
+import { monthsOf } from "./calendar";
+
+/**
+ * The loc keys a game formats dates through, verified against the game's
+ * binary/files. Lives in the GameProfile (`games/<id>/meta.ts`); a profile
+ * without one does not support generation.
+ */
+export interface CalendarLocSpec {
+  /**
+   * Vanilla date-format keys to override in `localization/replace/`, mapped
+   * to their format template. `{year}` and `{era}` mark where the generated
+   * era-math key references go; everything else is kept verbatim (the
+   * vanilla `$DAY$`/`$MONTH$` parameters).
+   */
+  dateFormats: Record<string, string>;
+  /**
+   * Engine month-name loc keys, first month first: [longKey, shortKey].
+   * Overridden only when the calendar declares custom months, and only when
+   * it declares exactly as many months as the engine has.
+   */
+  monthKeys?: [string, string][];
+}
+
+/** One file the generator wants written, path relative to the mod root. */
+export interface GeneratedLocFile {
+  /** Forward slashes; the writer joins it onto the mod root. */
+  relPath: string;
+  /** Content without BOM; the writer prepends it. */
+  content: string;
+}
+
+export interface CalendarLocResult {
+  files: GeneratedLocFile[];
+  /** Facts the modder should know after generating (limits, follow-ups). */
+  notes: string[];
+}
+
+/** Keys the generated files define; exported so tests and docs stay in sync. */
+export const CAL_YEAR_KEY = "PX_CAL_YEAR";
+export const CAL_ERA_KEY = "PX_CAL_ERA";
+
+/** Era labels sit inside '...' CString literals; a quote would break the
+ * datafunction silently, which is exactly the failure class we exist to
+ * prevent. */
+function cstring(label: string): string {
+  return label.replace(/'/g, "");
+}
+
+/**
+ * `[Select_int32(...)]` era math for the year, mirroring
+ * calendar.ts `displayYear`: y >= epoch shows as y - (epoch - 1), below as
+ * epoch - y. A single-era calendar (no `before`) clamps to 1 instead, so
+ * pre-epoch years never display as 0 or negative.
+ */
+function yearExpr(cal: CalendarSetting): string {
+  const year = "'(int32)$YEAR|q$'";
+  const toAfter = `Subtract_int32( ${year}, '(int32)${cal.epoch - 1}' )`;
+  if (!cal.before) return `[Max_int32( ${toAfter}, '(int32)1' )]`;
+  const toBefore = `Subtract_int32( '(int32)${cal.epoch}', ${year} )`;
+  return `[Select_int32( GreaterThanOrEqualTo_int32( ${year}, '(int32)${cal.epoch}' ), ${toAfter}, ${toBefore} )]`;
+}
+
+function eraExpr(cal: CalendarSetting): string {
+  if (!cal.before) return cal.after;
+  return (
+    `[Select_CString( GreaterThanOrEqualTo_int32( '(int32)$YEAR|q$', '(int32)${cal.epoch}' ), ` +
+    `'${cstring(cal.after)}', '${cstring(cal.before)}' )]`
+  );
+}
+
+function locFile(lang: string, lines: string[]): string {
+  return [`l_${lang}:`, ...lines, ""].join("\n");
+}
+
+/**
+ * The two files implementing the calendar in game:
+ *
+ * - `localization/<lang>/px_calendar_l_<lang>.yml` - the era-math keys
+ *   (new keys, so NOT in replace/).
+ * - `localization/replace/<lang>/px_calendar_dates_l_<lang>.yml` - the
+ *   vanilla date-format overrides routing `$YEAR$` through them, plus the
+ *   engine month-name overrides when the calendar has custom months.
+ *
+ * Deterministic filenames: regenerating after a `px.calendar` change
+ * overwrites the same two files.
+ */
+export function generateCalendarLoc(
+  cal: CalendarSetting,
+  spec: CalendarLocSpec,
+  lang: string
+): CalendarLocResult {
+  const notes: string[] = [];
+  const header = [
+    " # Generated by 'Paradox: Generate Calendar Localization' from the px.calendar",
+    " # setting. Edit px.calendar and regenerate instead of editing by hand.",
+  ];
+
+  const eraDoc = cal.before
+    ? ` # Script year >= ${cal.epoch} shows as (year - ${cal.epoch - 1}) ${cal.after}; below as (${cal.epoch} - year) ${cal.before}.`
+    : ` # Script year >= ${cal.epoch} shows as (year - ${cal.epoch - 1}) ${cal.after}; earlier years clamp to 1.`;
+  const mathLines = [
+    ...header,
+    eraDoc,
+    ` ${CAL_YEAR_KEY}:0 "${yearExpr(cal)}"`,
+    ` ${CAL_ERA_KEY}:0 "${eraExpr(cal)}"`,
+  ];
+
+  const overrideLines = [
+    ...header,
+    " # Overrides of the engine's date-format keys: same formats as vanilla, with",
+    ` # the raw $YEAR$ routed through ${CAL_YEAR_KEY}/${CAL_ERA_KEY}.`,
+  ];
+  for (const [key, format] of Object.entries(spec.dateFormats)) {
+    const value = format.replace("{year}", `$${CAL_YEAR_KEY}$`).replace("{era}", `$${CAL_ERA_KEY}$`);
+    overrideLines.push(` ${key}:0 "${value}"`);
+  }
+
+  if (cal.months) {
+    const months = monthsOf(cal);
+    if (!spec.monthKeys) {
+      notes.push("This game's month-name keys are not mapped yet; custom month names were not generated.");
+    } else if (months.length !== spec.monthKeys.length) {
+      notes.push(
+        `The engine has exactly ${spec.monthKeys.length} months; your calendar declares ${months.length}, ` +
+          "so month names were not generated (the month count itself cannot be modded)."
+      );
+    } else {
+      overrideLines.push(" # Engine month names (long and abbreviated forms both get the custom name).");
+      months.forEach((m, i) => {
+        const [long, short] = spec.monthKeys![i];
+        overrideLines.push(` ${long}:0 "${m.name.replace(/"/g, '\\"')}"`);
+        if (short !== long) overrideLines.push(` ${short}:0 "${m.name.replace(/"/g, '\\"')}"`);
+      });
+      notes.push(
+        "Month day counts are engine-fixed (31/28/31...); custom day counts only affect the editor's display."
+      );
+    }
+  }
+
+  notes.push(
+    `Generated for '${lang}' only; other languages the mod ships need the same overrides in their replace folder.`
+  );
+
+  return {
+    files: [
+      { relPath: `localization/${lang}/px_calendar_l_${lang}.yml`, content: locFile(lang, mathLines) },
+      {
+        relPath: `localization/replace/${lang}/px_calendar_dates_l_${lang}.yml`,
+        content: locFile(lang, overrideLines),
+      },
+    ],
+    notes,
+  };
+}

package/src/constants.ts

@@ -1,12 +1,12 @@
-/**
- * Constants needed on both sides of the LSP boundary.
- */
-import type { TokenKind } from "./types";
-
-/** The script_docs log files and the token kind each one contributes. */
-export const LOG_FILES: Array<{ file: string; kind: TokenKind }> = [
-  { file: "triggers.log", kind: "trigger" },
-  { file: "effects.log", kind: "effect" },
-  { file: "event_targets.log", kind: "event_target" },
-  { file: "modifiers.log", kind: "modifier" },
-];
+/**
+ * Constants needed on both sides of the LSP boundary.
+ */
+import type { TokenKind } from "./types";
+
+/** The script_docs log files and the token kind each one contributes. */
+export const LOG_FILES: Array<{ file: string; kind: TokenKind }> = [
+  { file: "triggers.log", kind: "trigger" },
+  { file: "effects.log", kind: "effect" },
+  { file: "event_targets.log", kind: "event_target" },
+  { file: "modifiers.log", kind: "modifier" },
+];