modwright 0.1.0

package/dist/surfaces/baldursgate3/index/queries.js

@@ -0,0 +1,327 @@
+const DEFAULT_LIMIT = 50;
+const MAX_USING_DEPTH = 10;
+function str(v) {
+    if (v === undefined)
+        return undefined;
+    const s = String(v).trim();
+    return s.length > 0 ? s : undefined;
+}
+function limitOf(params) {
+    const n = Number(params.limit);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_LIMIT;
+}
+function page(rows, limit) {
+    if (rows.length > limit)
+        return { rows: rows.slice(0, limit), truncated: true };
+    return { rows, truncated: false };
+}
+function result(kind, params, rows, truncated, note) {
+    return { kind, params, count: rows.length, truncated, rows, note };
+}
+function parseAttrsJson(raw) {
+    try {
+        return JSON.parse(String(raw));
+    }
+    catch {
+        return {};
+    }
+}
+function fieldsForStat(store, statId) {
+    const fields = {};
+    for (const row of store.all(`SELECT field, value FROM stat_field WHERE stat_id = ? ORDER BY field`, [statId])) {
+        fields[String(row.field)] = String(row.value);
+    }
+    return fields;
+}
+function usingChainFor(store, startUsing) {
+    const chain = [];
+    const seen = new Set();
+    let current = startUsing;
+    let depth = 0;
+    while (current && depth < MAX_USING_DEPTH && !seen.has(current)) {
+        seen.add(current);
+        const row = store.get(`SELECT name, type, "using" AS parent FROM stat WHERE name = ? LIMIT 1`, [current]);
+        if (!row)
+            break;
+        chain.push({ name: String(row.name), type: String(row.type) });
+        current = row.parent === null || row.parent === undefined ? undefined : String(row.parent);
+        depth++;
+    }
+    return chain;
+}
+function queryStat(store, params) {
+    const name = str(params.name);
+    const prefix = str(params.prefix);
+    const type = str(params.type);
+    const limit = limitOf(params);
+    if (!name && !prefix) {
+        return result("stat", params, [], false, "No 'name' or 'prefix' given; nothing searched.");
+    }
+    let sql = `SELECT id, name, type, "using" AS parent, source_id, file, line FROM stat WHERE `;
+    const args = [];
+    if (name) {
+        sql += `name = ?`;
+        args.push(name);
+    }
+    else {
+        sql += `name LIKE ?`;
+        args.push(`${prefix}%`);
+    }
+    if (type) {
+        sql += ` AND type = ?`;
+        args.push(type);
+    }
+    sql += ` ORDER BY name LIMIT ?`;
+    args.push(limit + 1);
+    const rows = store.all(sql, args);
+    const { rows: pageRows, truncated } = page(rows, limit);
+    const mapped = pageRows.map((row) => {
+        const id = Number(row.id);
+        const parent = row.parent === null || row.parent === undefined ? undefined : String(row.parent);
+        return {
+            name: row.name,
+            type: row.type,
+            using: parent ?? null,
+            usingChain: usingChainFor(store, parent),
+            fields: fieldsForStat(store, id),
+            source: row.source_id,
+            file: row.file,
+            line: row.line,
+        };
+    });
+    const how = name ? `exact name '${name}'` : `name prefix '${prefix}'`;
+    const note = `Searched stat entries by ${how}${type ? ` filtered to type '${type}'` : ""}.`;
+    return result("stat", params, mapped, truncated, note);
+}
+function queryField(store, params) {
+    const field = str(params.field);
+    if (!field)
+        return result("field", params, [], false, "No 'field' given; nothing searched.");
+    const type = str(params.type);
+    const limit = limitOf(params);
+    let sql = `SELECT sf.value AS value, COUNT(*) AS n FROM stat_field sf`;
+    const args = [];
+    if (type) {
+        sql += ` JOIN stat s ON s.id = sf.stat_id WHERE sf.field = ? AND s.type = ?`;
+        args.push(field, type);
+    }
+    else {
+        sql += ` WHERE sf.field = ?`;
+        args.push(field);
+    }
+    sql += ` GROUP BY sf.value ORDER BY n DESC, sf.value LIMIT ?`;
+    args.push(limit + 1);
+    const rows = store.all(sql, args);
+    const { rows: pageRows, truncated } = page(rows, limit);
+    const mapped = pageRows.map((row) => ({ value: row.value, count: Number(row.n) }));
+    const note = `Searched values of field '${field}'${type ? ` on type '${type}'` : ""} across all indexed stats.`;
+    return result("field", params, mapped, truncated, note);
+}
+function queryPrecedent(store, params) {
+    const field = str(params.field);
+    const token = str(params.token);
+    if (!field || !token) {
+        return result("precedent", params, [], false, "Both 'field' and 'token' are required; nothing searched.");
+    }
+    const type = str(params.type);
+    const contextField = str(params.contextField);
+    const contextToken = str(params.contextToken);
+    const limit = limitOf(params);
+    let sql = `SELECT s.name AS name, s.type AS type, sf.value AS value
+             FROM stat_field sf JOIN stat s ON s.id = sf.stat_id
+             WHERE sf.field = ? AND sf.value LIKE ?`;
+    const args = [field, `%${token}%`];
+    if (type) {
+        sql += ` AND s.type = ?`;
+        args.push(type);
+    }
+    if (contextField && contextToken) {
+        sql += ` AND EXISTS (SELECT 1 FROM stat_field cf WHERE cf.stat_id = s.id AND cf.field = ? AND cf.value LIKE ?)`;
+        args.push(contextField, `%${contextToken}%`);
+    }
+    sql += ` ORDER BY s.name LIMIT ?`;
+    args.push(limit + 1);
+    const rows = store.all(sql, args);
+    const { rows: pageRows, truncated } = page(rows, limit);
+    const mapped = pageRows.map((row) => ({ name: row.name, type: row.type, field, value: row.value }));
+    const contextNote = contextField && contextToken ? ` where '${contextField}' also contains '${contextToken}'` : "";
+    const note = `Vanilla precedent census: stats whose '${field}' contains '${token}'${contextNote}${type ? ` (type '${type}')` : ""}.`;
+    return result("precedent", params, mapped, truncated, note);
+}
+function queryGuid(store, params) {
+    const uuid = str(params.uuid);
+    const name = str(params.name);
+    if (!uuid && !name) {
+        return result("guid", params, [], false, "No 'uuid' or 'name' given; nothing searched.");
+    }
+    const limit = limitOf(params);
+    let sql = `SELECT source_id, file, region, node_id, path, uuid, name, attrs_json FROM node WHERE `;
+    const args = [];
+    if (uuid) {
+        sql += `uuid = ?`;
+        args.push(uuid);
+    }
+    else {
+        sql += `name = ?`;
+        args.push(name);
+    }
+    sql += ` ORDER BY node_id, name LIMIT ?`;
+    args.push(limit + 1);
+    const rows = store.all(sql, args);
+    const { rows: pageRows, truncated } = page(rows, limit);
+    const mapped = pageRows.map((row) => ({
+        kind: row.node_id,
+        uuid: row.uuid,
+        name: row.name,
+        file: row.file,
+        region: row.region,
+        path: row.path,
+        attributes: parseAttrsJson(row.attrs_json),
+    }));
+    const note = uuid ? `Looked up node(s) by UUID '${uuid}'.` : `Resolved node(s) named '${name}' to their UUID.`;
+    return result("guid", params, mapped, truncated, note);
+}
+function queryList(store, params) {
+    const uuid = str(params.uuid);
+    const name = str(params.name);
+    const kindFilter = str(params.kind);
+    const limit = limitOf(params);
+    let sql;
+    const args = [];
+    if (kindFilter) {
+        sql = `SELECT file, region, node_id, path, uuid, name, attrs_json FROM node WHERE node_id = ?`;
+        args.push(kindFilter);
+    }
+    else {
+        sql = `SELECT file, region, node_id, path, uuid, name, attrs_json FROM node WHERE node_id IN ('SpellList', 'Progression')`;
+    }
+    if (uuid) {
+        sql += ` AND uuid = ?`;
+        args.push(uuid);
+    }
+    if (name) {
+        sql += ` AND name = ?`;
+        args.push(name);
+    }
+    sql += ` ORDER BY node_id, name LIMIT ?`;
+    args.push(limit + 1);
+    const rows = store.all(sql, args);
+    const { rows: pageRows, truncated } = page(rows, limit);
+    const mapped = pageRows.map((row) => {
+        const attributes = parseAttrsJson(row.attrs_json);
+        const entry = {
+            kind: row.node_id,
+            uuid: row.uuid,
+            name: row.name,
+            file: row.file,
+            region: row.region,
+            path: row.path,
+            attributes,
+        };
+        if (row.node_id === "SpellList") {
+            const spells = attributes.Spells?.value ?? "";
+            entry.spells = spells.length > 0 ? spells.split(";") : [];
+        }
+        return entry;
+    });
+    const how = uuid ? `uuid '${uuid}'` : name ? `name '${name}'` : kindFilter ? `kind '${kindFilter}'` : "all lists/progressions";
+    const note = `Searched SpellList/Progression nodes by ${how}.`;
+    return result("list", params, mapped, truncated, note);
+}
+function queryHandle(store, params) {
+    const handle = str(params.handle);
+    const text = str(params.text);
+    const limit = limitOf(params);
+    if (handle) {
+        const row = store.get(`SELECT handle, version, text FROM loca WHERE handle = ?`, [handle]);
+        const rows = row ? [row] : [];
+        return result("handle", params, rows, false, `Looked up localization handle '${handle}'.`);
+    }
+    if (text) {
+        const rows = store.all(`SELECT l.handle AS handle, l.version AS version, l.text AS text
+       FROM loca_fts f JOIN loca l ON l.handle = f.handle
+       WHERE loca_fts MATCH ? LIMIT ?`, [text, limit + 1]);
+        const { rows: pageRows, truncated } = page(rows, limit);
+        return result("handle", params, pageRows, truncated, `Full-text search over localization text for '${text}'.`);
+    }
+    return result("handle", params, [], false, "No 'handle' or 'text' given; nothing searched.");
+}
+function queryAtlas(store, params) {
+    const atlas = str(params.atlas);
+    if (!atlas)
+        return result("atlas", params, [], false, "No 'atlas' given; nothing searched.");
+    const limit = limitOf(params);
+    const rows = store.all(`SELECT file, name AS key, attrs_json FROM node WHERE node_id = 'IconUV' AND file LIKE ? ORDER BY name LIMIT ?`, [`%${atlas}%`, limit + 1]);
+    const { rows: pageRows, truncated } = page(rows, limit);
+    const mapped = pageRows.map((row) => {
+        const attrs = parseAttrsJson(row.attrs_json);
+        return {
+            file: row.file,
+            key: row.key,
+            u1: attrs.U1?.value,
+            u2: attrs.U2?.value,
+            v1: attrs.V1?.value,
+            v2: attrs.V2?.value,
+        };
+    });
+    return result("atlas", params, mapped, truncated, `IconUV keys in atlas file(s) matching '${atlas}'.`);
+}
+export function queryKinds() {
+    return [
+        {
+            kind: "stat",
+            description: "A stat entry by exact or prefix name, with its using-chain (up to 10 levels) and own fields.",
+            params: ["name", "prefix", "type", "limit"],
+        },
+        {
+            kind: "field",
+            description: "Every distinct value of a field across indexed stats, with counts, optionally filtered by type.",
+            params: ["field", "type", "limit"],
+        },
+        {
+            kind: "precedent",
+            description: "Vanilla precedent census: every stat whose field value contains a token, optionally filtered by a second field's value (e.g. passives whose BoostContext contains OnCast).",
+            params: ["field", "token", "contextField", "contextToken", "type", "limit"],
+        },
+        {
+            kind: "guid",
+            description: "LSX nodes by UUID, or resolve a node name to its UUID.",
+            params: ["uuid", "name", "limit"],
+        },
+        {
+            kind: "list",
+            description: "SpellList/Progression nodes by uuid or name, with their contents (a SpellList's member spells split out).",
+            params: ["kind", "uuid", "name", "limit"],
+        },
+        {
+            kind: "handle",
+            description: "Localization lookup by handle, or a full-text search over localization text.",
+            params: ["handle", "text", "limit"],
+        },
+        {
+            kind: "atlas",
+            description: "IconUV keys and UV rects in a GUI atlas, matched against the atlas file's name.",
+            params: ["atlas", "limit"],
+        },
+    ];
+}
+export async function query(store, kind, params) {
+    switch (kind) {
+        case "stat":
+            return queryStat(store, params);
+        case "field":
+            return queryField(store, params);
+        case "precedent":
+            return queryPrecedent(store, params);
+        case "guid":
+            return queryGuid(store, params);
+        case "list":
+            return queryList(store, params);
+        case "handle":
+            return queryHandle(store, params);
+        case "atlas":
+            return queryAtlas(store, params);
+        default:
+            throw new Error(`Unknown BG3 index query kind: '${kind}'. See queryKinds() for the supported set.`);
+    }
+}

package/dist/surfaces/baldursgate3/index/schema.js

@@ -0,0 +1,62 @@
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS source (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  path TEXT NOT NULL,
+  mtime TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS stat (
+  id INTEGER PRIMARY KEY,
+  name TEXT NOT NULL COLLATE NOCASE,
+  type TEXT NOT NULL,
+  "using" TEXT,
+  source_id TEXT NOT NULL,
+  file TEXT NOT NULL,
+  line INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_stat_name ON stat(name);
+CREATE INDEX IF NOT EXISTS idx_stat_type ON stat(type);
+CREATE INDEX IF NOT EXISTS idx_stat_using ON stat("using");
+
+CREATE TABLE IF NOT EXISTS stat_field (
+  id INTEGER PRIMARY KEY,
+  stat_id INTEGER NOT NULL,
+  field TEXT NOT NULL COLLATE NOCASE,
+  value TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_stat_field_field ON stat_field(field);
+CREATE INDEX IF NOT EXISTS idx_stat_field_stat_id ON stat_field(stat_id);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS stat_field_fts USING fts4(name, field, value);
+
+CREATE TABLE IF NOT EXISTS node (
+  id INTEGER PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  file TEXT NOT NULL,
+  region TEXT NOT NULL,
+  node_id TEXT NOT NULL,
+  path TEXT NOT NULL,
+  uuid TEXT COLLATE NOCASE,
+  name TEXT COLLATE NOCASE,
+  attrs_json TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_node_uuid ON node(uuid);
+CREATE INDEX IF NOT EXISTS idx_node_name ON node(name);
+CREATE INDEX IF NOT EXISTS idx_node_node_id ON node(node_id);
+
+CREATE TABLE IF NOT EXISTS loca (
+  handle TEXT PRIMARY KEY,
+  version INTEGER NOT NULL,
+  text TEXT NOT NULL
+);
+CREATE VIRTUAL TABLE IF NOT EXISTS loca_fts USING fts4(handle, text);
+
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+`;
+export function createSchema(store) {
+    store.exec(SCHEMA_SQL);
+}

package/dist/surfaces/baldursgate3/index.js

@@ -0,0 +1,3 @@
+export { baldursgate3 } from "./surface.js";
+export { SIGNATURES } from "./logs.js";
+export { bg3Index } from "./index/index.js";

package/dist/surfaces/baldursgate3/logs.js

@@ -0,0 +1,278 @@
+const GAME = "baldursgate3";
+const SE_VERSION = {
+    id: "baldursgate3.se.version",
+    game: GAME,
+    sources: ["extender"],
+    severity: "info",
+    category: "success",
+    pattern: /^BG3Ext v(?<version>\d+) built on (?<built>.+?)\s*$/,
+    explain: "Script Extender started and printed its build banner, so DWrite.dll is loaded and SE " +
+        "itself is running.",
+    hint: "The version number is SE's own build (v23, v24, ...), not the game patch. SE is " +
+        "re-released after nearly every BG3 patch; if the game updated recently, check that " +
+        "this build matches the patch before blaming a mod.",
+    seenIn: [
+        "test/fixtures/logs/bg3/ScriptExtender.synthetic.log",
+        "https://github.com/Norbyte/bg3se/issues/508",
+    ],
+    extract: ["version", "built"],
+};
+const SE_MODULE_LOADED = {
+    id: "baldursgate3.se.module-loaded",
+    game: GAME,
+    sources: ["extender"],
+    severity: "info",
+    category: "success",
+    pattern: /^(?<side>ecl|esv)::ScriptExtender::OnGameStateChanged\(\): Loaded module/,
+    explain: "Script Extender saw a module finish loading (ecl = client, esv = server), which is the " +
+        "positive confirmation that SE is attached to this session.",
+    hint: "Expect one for each side. A client line with no server line means server-side Lua " +
+        "(BootstrapServer.lua, Osiris subscribers) never ran.",
+    seenIn: [
+        "test/fixtures/logs/bg3/ScriptExtender.synthetic.log",
+        "https://github.com/Norbyte/bg3se/issues/508",
+    ],
+    extract: ["side"],
+};
+const SE_MAPPING_NOT_FOUND = {
+    id: "baldursgate3.se.mapping-not-found",
+    game: GAME,
+    sources: ["extender"],
+    severity: "warn",
+    category: "version",
+    pattern: /^No match found for mapping '(?<symbol>[^']+)'/,
+    explain: "Script Extender could not locate a game function it hooks, so the feature behind that " +
+        "hook is silently inactive this session.",
+    hint: "Almost always a version gap: the game patched and this SE build has not caught up. " +
+        "Update Script Extender before investigating any mod that depends on the missing feature.",
+    seenIn: [
+        "test/fixtures/logs/bg3/ScriptExtender.synthetic.log",
+        "https://github.com/Norbyte/bg3se/issues/508",
+    ],
+    extract: ["symbol"],
+};
+const SE_RUNTIME_LOG_PATH = {
+    id: "baldursgate3.se.runtime-log-path",
+    game: GAME,
+    sources: ["extender"],
+    severity: "info",
+    category: "load",
+    pattern: /^Extender runtime log written to '(?<path>[^']+)'/,
+    explain: "Script Extender wrote its runtime log to this path — the file that actually carries Lua " +
+        "output for this session.",
+    hint: "If that path is not one of the candidates ModWright resolves, set LogDirectory in " +
+        "ScriptExtenderSettings.json to a stable folder, or read this file directly.",
+    seenIn: [
+        "test/fixtures/logs/bg3/ScriptExtender.synthetic.log",
+        "https://github.com/Norbyte/bg3se/issues/508",
+    ],
+    extract: ["path"],
+};
+const SE_LUA_ERROR = {
+    id: "baldursgate3.se.lua-error",
+    game: GAME,
+    sources: ["extender"],
+    severity: "error",
+    category: "script",
+    pattern: /(?:Mods[/\\](?<mod>[^/\\:"']+)[/\\])?(?<file>[^\s"']*\.lua):(?<line>\d+):\s*(?<message>\S.*?)\s*$/,
+    explain: "A Script Extender Lua script raised a runtime error at this file and line; everything " +
+        "after the failing call in that script did not run.",
+    hint: "Fix the script, then reload with SE's console rather than a full relaunch — but note " +
+        "that a mid-session `reset` degrades Osiris (see baldursgate3.osiris.db-not-available).",
+    seenIn: ["unverified: tolerant pattern"],
+    extract: ["mod", "file", "line", "message"],
+};
+const OSIRIS_SUBSCRIBER_FAILED = {
+    id: "baldursgate3.osiris.subscriber-register-failed",
+    game: GAME,
+    sources: ["extender", "osiris"],
+    severity: "error",
+    category: "resource",
+    pattern: /Couldn't register Osiris subscriber for (?<event>[^\s/]+)\/(?<arity>\d+)(?:\s*:\s*(?<reason>.+?))?\s*$/,
+    explain: "A Lua script subscribed to an Osiris event that the loaded story does not define, so the " +
+        "handler will never fire — the mod looks inert with no further error.",
+    hint: "Check the event name and arity against the story actually loaded: the name must match a " +
+        "story symbol exactly, and the number after the slash is its parameter count. A story " +
+        "that failed to compile leaves every symbol missing, so look for compile errors first.",
+    seenIn: [
+        "test/fixtures/logs/bg3/ScriptExtender.synthetic.log",
+        "test/fixtures/logs/bg3/Osiris.synthetic.log",
+        "https://github.com/Norbyte/bg3se/issues/420",
+    ],
+    extract: ["event", "arity", "reason"],
+};
+const OSIRIS_SYMBOL_NOT_FOUND = {
+    id: "baldursgate3.osiris.symbol-not-found",
+    game: GAME,
+    sources: ["extender", "osiris"],
+    severity: "error",
+    category: "resource",
+    pattern: /^(?!.*Couldn't register Osiris subscriber).*Symbol not found in story/,
+    explain: "Osiris was asked for a story symbol that does not exist in the compiled story.",
+    hint: "Either the symbol is misspelled, or the story it lives in never compiled — a story that " +
+        "fails to compile makes every one of its symbols missing at once.",
+    seenIn: [
+        "https://github.com/Norbyte/bg3se/issues/420",
+        "unverified: tolerant pattern (the verified line is the subscriber form above; this " +
+            "catches the same wording in any other context)",
+    ],
+};
+const OSIRIS_BAD_PREFIX = {
+    id: "baldursgate3.osiris.bad-prefix",
+    game: GAME,
+    sources: ["osiris", "extender"],
+    severity: "error",
+    category: "compile",
+    pattern: /^Osiris fact\/proc\/query (?<symbol>\S+) does not start with 'DB_'\/'PROC_'\/'QRY_'/,
+    explain: "An Osiris fact, procedure or query is named without the mandatory DB_ / PROC_ / QRY_ " +
+        "prefix, which disables the story component that declares it — silently, at runtime.",
+    hint: "Rename the symbol to the prefix matching its kind (DB_ for facts, PROC_ for procedures, " +
+        "QRY_ for queries) and update every reference, including Lua-side Osi.* calls.",
+    seenIn: [
+        "test/fixtures/logs/bg3/Osiris.synthetic.log",
+        "https://github.com/Norbyte/bg3se/issues/25",
+    ],
+    extract: ["symbol"],
+};
+const OSIRIS_DB_NOT_AVAILABLE = {
+    id: "baldursgate3.osiris.db-not-available",
+    game: GAME,
+    sources: ["osiris", "extender"],
+    severity: "warn",
+    category: "load",
+    pattern: /^\s*Not syncing adapters - DB not available/,
+    explain: "The Osiris database is not available, so adapters were not synced. After a mid-session SE " +
+        "`reset` this is the marker that Osiris is degraded: Lua reloads cleanly while Osi.* " +
+        "queries return junk.",
+    hint: "Do not trust any Osiris-derived result printed after this line. Relaunch the game rather " +
+        "than resetting again, and re-run the check from a fresh session before concluding " +
+        "anything about the mod.",
+    seenIn: [
+        "test/fixtures/logs/bg3/Osiris.synthetic.log",
+        "a mod project's own dev notes, via " +
+            "test/fixtures/logs/FORMATS.md section 6",
+    ],
+};
+const OSIRIS_ERROR_LINE = {
+    id: "baldursgate3.osiris.error-line",
+    game: GAME,
+    sources: ["osiris"],
+    severity: "error",
+    category: "compile",
+    pattern: /^Osiris\b(?=.*\b(?:error|errors|failed|failure)\b).*$/i,
+    explain: "Osiris reported an error or failure. Osiris does not attribute errors to the mod that " +
+        "caused them, so the line above and below this one are usually more informative than the " +
+        "message itself.",
+    hint: "Osiris compile failures cascade: one bad goal file leaves every symbol it declares " +
+        "missing. Enable LogCompile / LogFailedCompile in ScriptExtenderSettings.json and " +
+        "re-launch to get the compile output alongside this line.",
+    seenIn: ["unverified: tolerant pattern"],
+};
+const OSIRIS_RULE_FIRED = {
+    id: "baldursgate3.osiris.rule-fired",
+    game: GAME,
+    sources: ["osiris"],
+    severity: "info",
+    category: "success",
+    pattern: /^(?<depth>\d+)-*> RuleActionPart of THEN at line (?<line>\d+) fires\b/,
+    explain: "The Osiris story engine executed a rule, so the compiled story is loaded and running. " +
+        "The first is reported; `repeats` counts the rest in the scanned window.",
+    hint: "A mod's own goals show up as PROC_/DB_ names on the indented lines that follow; searching " +
+        "the log for the mod's prefix is the fastest way to see whether its rules ever fire.",
+    seenIn: ["test/fixtures/logs/bg3/real/osiris.log"],
+    extract: ["depth", "line"],
+};
+const OSIRIS_EVENT = {
+    id: "baldursgate3.osiris.event",
+    game: GAME,
+    sources: ["osiris"],
+    severity: "info",
+    category: "load",
+    pattern: /^>>> event (?<event>\w+)\(/,
+    explain: "An engine event reached Osiris. Events are what a story rule's IF part listens for.",
+    seenIn: ["test/fixtures/logs/bg3/real/osiris.log"],
+    extract: ["event"],
+};
+const NETWORK_STATE_SWAP = {
+    id: "baldursgate3.network.state-swap",
+    game: GAME,
+    sources: ["network"],
+    severity: "info",
+    category: "load",
+    pattern: /\b(?<side>SERVER|CLIENT) STATE SWAP - from: (?<from>[^,]+), to: (?<to>\S+)/,
+    explain: "The game state machine advanced. Reported once with the first swap of the scan; " +
+        "`repeats` counts the rest, so a low repeat count means the game did not get far.",
+    hint: "Read the last swap in the file, not this one: the state it stopped at is where the game " +
+        "died. Corroborate with a bin/CrashDump*.dmp written at the same minute.",
+    seenIn: [
+        "test/fixtures/logs/bg3/network.synthetic.log",
+        "https://pastebin.com/x1aQyDxz",
+    ],
+    extract: ["side", "from", "to"],
+};
+const NETWORK_MODULE_LOAD = {
+    id: "baldursgate3.network.module-load",
+    game: GAME,
+    sources: ["network"],
+    severity: "info",
+    category: "load",
+    pattern: /\b(?:SERVER|CLIENT) STATE SWAP - from: (?<from>[^,]+), to: LoadModule\b/,
+    explain: "The game entered LoadModule: modules and assets are being loaded, which is where a bad " +
+        "load order or an unresolvable .pak takes the process down.",
+    hint: "If this is the last state in the log, treat it as a module-load crash, not a level " +
+        "transition: check modsettings.lsx against the paks actually in Mods/, and bisect the " +
+        "order rather than the mod's content.",
+    seenIn: [
+        "test/fixtures/logs/bg3/network.synthetic.log",
+        "a mod's own notes on a load-order CTD at LoadModule",
+    ],
+    extract: ["from"],
+};
+const NETWORK_MAIN_MENU = {
+    id: "baldursgate3.network.main-menu",
+    game: GAME,
+    sources: ["network"],
+    severity: "info",
+    category: "success",
+    pattern: /\b(?:SERVER|CLIENT) STATE SWAP - from: (?<from>[^,]+), to: Menu\s*$/,
+    explain: "The client reached the main menu, so module and asset loading completed for this run — " +
+        "any crash after this point is not a load-order problem.",
+    seenIn: [
+        "test/fixtures/logs/bg3/network.synthetic.log",
+        "https://pastebin.com/x1aQyDxz",
+    ],
+    extract: ["from"],
+};
+const NETWORK_STATE_QUEUED = {
+    id: "baldursgate3.network.state-queued",
+    game: GAME,
+    sources: ["network"],
+    severity: "info",
+    category: "load",
+    pattern: /\b(?<side>esv|ecl)::GameStateQueued: (?<state>\S+)/,
+    explain: "A state was queued as the next target (esv = server, ecl = client). A queued state with " +
+        "no matching STATE SWAP afterwards means the transition was requested but never completed.",
+    seenIn: [
+        "test/fixtures/logs/bg3/network.synthetic.log",
+        "https://pastebin.com/x1aQyDxz",
+    ],
+    extract: ["side", "state"],
+};
+export const SIGNATURES = [
+    SE_VERSION,
+    SE_MODULE_LOADED,
+    SE_MAPPING_NOT_FOUND,
+    SE_RUNTIME_LOG_PATH,
+    SE_LUA_ERROR,
+    OSIRIS_SUBSCRIBER_FAILED,
+    OSIRIS_SYMBOL_NOT_FOUND,
+    OSIRIS_BAD_PREFIX,
+    OSIRIS_DB_NOT_AVAILABLE,
+    OSIRIS_ERROR_LINE,
+    OSIRIS_RULE_FIRED,
+    OSIRIS_EVENT,
+    NETWORK_STATE_SWAP,
+    NETWORK_MODULE_LOAD,
+    NETWORK_MAIN_MENU,
+    NETWORK_STATE_QUEUED,
+];