modwright 0.1.0

package/dist/surfaces/skyrimse/archives.js

@@ -0,0 +1,229 @@
+import { promises as fs } from "node:fs";
+export const BSA_HEADER_LENGTH = 36;
+export const BSA_VERSION_OBLIVION = 103;
+export const BSA_VERSION_SKYRIM_LE = 104;
+export const BSA_VERSION_SKYRIM_SE = 105;
+export const BSA_FLAG_INCLUDE_DIRECTORY_NAMES = 0x1;
+export const BSA_FLAG_INCLUDE_FILE_NAMES = 0x2;
+export const BSA_FLAG_COMPRESSED = 0x4;
+export const BSA_FLAG_XBOX360 = 0x40;
+export const BSA_FLAG_EMBED_FILE_NAMES = 0x100;
+export const BSA_FLAG_XMEM = 0x200;
+export const BSA_FILE_SIZE_COMPRESSION_TOGGLE = 0x40000000;
+export const BSA_FILE_SIZE_MASK = 0x3fffffff;
+export const BSA_FILE_RECORD_LENGTH = 16;
+export const BSA_FILE_FLAGS = [
+    { bit: 0x1, name: "Meshes" },
+    { bit: 0x2, name: "Textures" },
+    { bit: 0x4, name: "Menus" },
+    { bit: 0x8, name: "Sounds" },
+    { bit: 0x10, name: "Voices" },
+    { bit: 0x20, name: "Shaders" },
+    { bit: 0x40, name: "Trees" },
+    { bit: 0x80, name: "Fonts" },
+    { bit: 0x100, name: "Miscellaneous" },
+];
+export class BsaHeaderError extends Error {
+    reason;
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+        this.name = "BsaHeaderError";
+    }
+}
+export function parseBsaHeader(buf) {
+    if (buf.length < BSA_HEADER_LENGTH) {
+        throw new BsaHeaderError(`archive is ${buf.length} bytes; a BSA header is ${BSA_HEADER_LENGTH}`, "too-short");
+    }
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const sig = String.fromCharCode(buf[0], buf[1], buf[2]) + (buf[3] === 0 ? "\\0" : String.fromCharCode(buf[3]));
+    if (!(buf[0] === 0x42 && buf[1] === 0x53 && buf[2] === 0x41 && buf[3] === 0)) {
+        throw new BsaHeaderError(`file id is "${sig}", not "BSA\\0"; not a Bethesda archive (a .ba2 is Fallout 4's format)`, "bad-signature");
+    }
+    const archiveFlags = view.getUint32(12, true);
+    const fileFlags = view.getUint16(32, true);
+    return {
+        version: view.getUint32(4, true),
+        folderRecordOffset: view.getUint32(8, true),
+        archiveFlags,
+        folderCount: view.getUint32(16, true),
+        fileCount: view.getUint32(20, true),
+        totalFolderNameLength: view.getUint32(24, true),
+        totalFileNameLength: view.getUint32(28, true),
+        fileFlags,
+        includesDirectoryNames: (archiveFlags & BSA_FLAG_INCLUDE_DIRECTORY_NAMES) !== 0,
+        includesFileNames: (archiveFlags & BSA_FLAG_INCLUDE_FILE_NAMES) !== 0,
+        compressedByDefault: (archiveFlags & BSA_FLAG_COMPRESSED) !== 0,
+        xbox360: (archiveFlags & BSA_FLAG_XBOX360) !== 0,
+        embedsFileNames: (archiveFlags & BSA_FLAG_EMBED_FILE_NAMES) !== 0,
+        contentTypes: BSA_FILE_FLAGS.filter((f) => (fileFlags & f.bit) !== 0).map((f) => f.name),
+    };
+}
+export async function readBsaHeader(filePath) {
+    const handle = await fs.open(filePath, "r");
+    try {
+        const buf = new Uint8Array(BSA_HEADER_LENGTH);
+        const { bytesRead } = await handle.read(buf, 0, BSA_HEADER_LENGTH, 0);
+        return parseBsaHeader(buf.subarray(0, bytesRead));
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function bsaFolderRecordLength(version) {
+    return version >= BSA_VERSION_SKYRIM_SE ? 24 : 16;
+}
+export function bsaTableLength(h) {
+    const folderRecords = h.folderCount * bsaFolderRecordLength(h.version);
+    const folderNames = h.includesDirectoryNames ? h.totalFolderNameLength + h.folderCount : 0;
+    const fileRecords = h.fileCount * BSA_FILE_RECORD_LENGTH;
+    const fileNames = h.includesFileNames ? h.totalFileNameLength : 0;
+    return BSA_HEADER_LENGTH + folderRecords + folderNames + fileRecords + fileNames;
+}
+const latin1 = new TextDecoder("latin1");
+export function parseBsaTable(buf) {
+    const header = parseBsaHeader(buf);
+    const tableLength = bsaTableLength(header);
+    if (buf.length < tableLength) {
+        throw new BsaHeaderError(`the folder and file tables need ${tableLength} bytes (header ${BSA_HEADER_LENGTH}, ${header.folderCount} folder record(s), ${header.fileCount} file record(s), the name blocks) but only ${buf.length} are there`, "truncated-table");
+    }
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const le = !header.xbox360;
+    const problems = [];
+    if (header.folderRecordOffset !== BSA_HEADER_LENGTH)
+        problems.push(`the header's folder-record offset is ${header.folderRecordOffset}; every BSA header is ${BSA_HEADER_LENGTH} bytes, so it is always ${BSA_HEADER_LENGTH}.`);
+    const recLen = bsaFolderRecordLength(header.version);
+    const folders = [];
+    let pos = BSA_HEADER_LENGTH;
+    for (let i = 0; i < header.folderCount; i++) {
+        const hash = view.getBigUint64(pos, le);
+        const count = view.getUint32(pos + 8, le);
+        const offsetField = view.getUint32(pos + (recLen === 24 ? 16 : 12), le);
+        folders.push({ index: i, hash, count, offsetField, blockOffset: offsetField - header.totalFileNameLength, actualBlockOffset: -1 });
+        pos += recLen;
+    }
+    const files = [];
+    let folderNameBytes = 0;
+    let overran = false;
+    const room = (n, what) => {
+        if (pos + n <= buf.length)
+            return true;
+        problems.push(`the file record blocks run past byte ${buf.length}, the end of the table the header describes, while reading ${what}; a folder record's file count or name length claims more than the header's counts and name lengths account for.`);
+        overran = true;
+        return false;
+    };
+    for (const folder of folders) {
+        folder.actualBlockOffset = pos;
+        if (folder.blockOffset !== pos)
+            problems.push(`folder record ${folder.index}'s offset points at byte ${folder.blockOffset} (after subtracting totalFileNameLength) but its file record block is at byte ${pos}.`);
+        if (header.includesDirectoryNames) {
+            if (!room(1, `folder record ${folder.index}'s name`))
+                break;
+            const len = buf[pos];
+            if (!room(1 + len, `folder record ${folder.index}'s name`))
+                break;
+            const raw = buf.subarray(pos + 1, pos + 1 + len);
+            const end = raw.indexOf(0);
+            folder.name = latin1.decode(end >= 0 ? raw.subarray(0, end) : raw);
+            if (len === 0 || end !== len - 1)
+                problems.push(`folder record ${folder.index}'s name is not a bzstring ending in \\0 (length byte ${len}).`);
+            folderNameBytes += len;
+            pos += 1 + len;
+        }
+        for (let j = 0; j < folder.count; j++) {
+            if (!room(BSA_FILE_RECORD_LENGTH, `folder record ${folder.index}'s file record ${j}`))
+                break;
+            const hash = view.getBigUint64(pos, le);
+            const sizeField = view.getUint32(pos + 8, le);
+            const offset = view.getUint32(pos + 12, le);
+            const toggled = (sizeField & BSA_FILE_SIZE_COMPRESSION_TOGGLE) !== 0;
+            files.push({ index: files.length, folder: folder.index, hash, sizeField, size: sizeField & BSA_FILE_SIZE_MASK, compressed: header.compressedByDefault !== toggled, offset });
+            pos += BSA_FILE_RECORD_LENGTH;
+        }
+        if (overran)
+            break;
+    }
+    if (overran)
+        return { header, folders, files, tableLength, problems };
+    if (files.length !== header.fileCount)
+        problems.push(`the folder records' counts add up to ${files.length} file(s) but the header says ${header.fileCount}.`);
+    if (header.includesDirectoryNames && folderNameBytes !== header.totalFolderNameLength)
+        problems.push(`the folder names take ${folderNameBytes} bytes but the header's totalFolderNameLength is ${header.totalFolderNameLength}.`);
+    if (header.includesFileNames) {
+        const block = buf.subarray(pos, pos + header.totalFileNameLength);
+        let start = 0;
+        let n = 0;
+        for (let k = 0; k < block.length && n < files.length; k++) {
+            if (block[k] === 0) {
+                files[n].name = latin1.decode(block.subarray(start, k));
+                n++;
+                start = k + 1;
+            }
+        }
+        if (n !== files.length)
+            problems.push(`the file name block holds ${n} name(s) for ${files.length} file record(s).`);
+        else if (start !== block.length)
+            problems.push(`the file name block has ${block.length - start} byte(s) after the last name; totalFileNameLength does not match the names.`);
+    }
+    return { header, folders, files, tableLength, problems };
+}
+export async function readBsaTable(filePath, maxTableBytes = 64 * 1024 * 1024) {
+    const handle = await fs.open(filePath, "r");
+    try {
+        const stat = await handle.stat();
+        const head = new Uint8Array(BSA_HEADER_LENGTH);
+        const first = await handle.read(head, 0, BSA_HEADER_LENGTH, 0);
+        const header = parseBsaHeader(head.subarray(0, first.bytesRead));
+        const want = Math.min(bsaTableLength(header), maxTableBytes, stat.size);
+        const buf = new Uint8Array(want);
+        const { bytesRead } = await handle.read(buf, 0, want, 0);
+        return { table: parseBsaTable(buf.subarray(0, bytesRead)), fileSize: stat.size };
+    }
+    finally {
+        await handle.close();
+    }
+}
+const HASH_MASK = 0xffffffffn;
+function fold(bytes) {
+    let h = 0n;
+    for (let i = 0; i < bytes.length; i++)
+        h = (h * 0x1003fn + BigInt(bytes.charCodeAt(i) & 0xff)) & HASH_MASK;
+    return h;
+}
+export function tesHash(name, kind) {
+    const lower = name.toLowerCase().replace(/\//g, "\\");
+    let root = lower;
+    let ext = "";
+    if (kind === "file") {
+        const dot = lower.lastIndexOf(".");
+        if (dot > 0) {
+            root = lower.slice(0, dot);
+            ext = lower.slice(dot);
+        }
+    }
+    if (root.length === 0)
+        return 0n;
+    const code = (i) => BigInt(root.charCodeAt(i) & 0xff);
+    let hash1 = code(root.length - 1) | (root.length > 2 ? code(root.length - 2) << 8n : 0n) | (BigInt(root.length) << 16n) | (code(0) << 24n);
+    if (ext === ".kf")
+        hash1 |= 0x80n;
+    else if (ext === ".nif")
+        hash1 |= 0x8000n;
+    else if (ext === ".dds")
+        hash1 |= 0x8080n;
+    else if (ext === ".wav")
+        hash1 |= 0x80000000n;
+    hash1 &= HASH_MASK;
+    const hash2 = (fold(root.slice(1, -2)) + fold(ext)) & HASH_MASK;
+    return (hash2 << 32n) + hash1;
+}
+export function bsaEntries(table) {
+    const out = [];
+    for (const f of table.files) {
+        const folder = table.folders[f.folder];
+        if (f.name === undefined || folder?.name === undefined)
+            continue;
+        out.push({ path: folder.name.length > 0 ? `${folder.name}\\${f.name}` : f.name, file: f });
+    }
+    return out;
+}

package/dist/surfaces/skyrimse/compat.js

@@ -0,0 +1,163 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { readPeFileVersion } from "../../core/compat/pe.js";
+import { compareVersions, parseVersion } from "../../core/compat/version.js";
+import { pathExists, readTextIfExists, resolveCandidate } from "../../core/fsutil.js";
+import { findMo2Profile, userDataDirs } from "./loadorder.js";
+export const SKSE_BUILDS = [
+    { skse: "2.3.1", runtime: { exact: "1.7.104" }, label: "Anniversary Edition (Steam)" },
+    { skse: "2.2.6", runtime: { min: "1.6.1170", max: "1.6.1179" }, label: "Anniversary Edition (GOG)" },
+    { skse: "2.0.20", runtime: { exact: "1.5.97" }, label: "Special Edition (pre-AE)" },
+];
+export const RUNTIME_EXPANDED_LIGHT_RANGE = "1.6.1130";
+const LOADER_BANNER_RE = /skse64 loader (\d+\.\d+\.\d+)/i;
+const VERSIONLIB_RE = /^(?:versionlib|version)-(\d+)-(\d+)-(\d+)-(\d+)\.bin$/i;
+function sameVersion(a, b) {
+    if (a === undefined || parseVersion(a) === undefined || parseVersion(b) === undefined)
+        return false;
+    return compareVersions(a, b) === 0;
+}
+async function detectComponents(install) {
+    const at = (...segments) => path.join(install.root, ...segments);
+    const components = [];
+    const dirs = await userDataDirs(install);
+    const gameExe = at("SkyrimSE.exe");
+    const gameInstalled = await pathExists(gameExe);
+    const gameVersion = install.version ?? (await readPeFileVersion(gameExe));
+    components.push({
+        id: "game",
+        label: "Skyrim Special Edition",
+        kind: "game",
+        installed: gameInstalled,
+        version: gameVersion,
+        source: gameVersion ? (install.version ? "install record" : "SkyrimSE.exe (PE FileVersion)") : undefined,
+        path: gameExe,
+    });
+    components.push({ id: `storefront-${dirs.storefront}`, label: `Storefront: ${dirs.storefront}`, kind: "game", installed: true, source: "game root probe (Galaxy64.dll / EOSSDK-Win64-Shipping.dll / install source)" });
+    const loader = at("skse64_loader.exe");
+    const skseInstalled = await pathExists(loader);
+    let skseVersion = await readPeFileVersion(loader);
+    let skseSource = skseVersion ? "skse64_loader.exe (PE FileVersion)" : undefined;
+    if (!skseVersion) {
+        const log = await readTextIfExists(path.join(dirs.myGames, "SKSE", "skse64_loader.log"));
+        const m = log?.match(LOADER_BANNER_RE);
+        if (m?.[1]) {
+            skseVersion = m[1];
+            skseSource = "skse64_loader.log (banner; wording unverified)";
+        }
+    }
+    components.push({ id: "skse", label: "SKSE64", kind: "loader", installed: skseInstalled || skseVersion !== undefined, version: skseVersion, source: skseSource, path: loader });
+    if (skseVersion) {
+        const known = SKSE_BUILDS.find((b) => sameVersion(skseVersion, b.skse));
+        components.push({
+            id: known ? `skse-build-${known.skse}` : "skse-build-unknown",
+            label: known ? `SKSE64 ${known.skse} (${known.label})` : `SKSE64 ${skseVersion} (not in the pairing table)`,
+            kind: "loader",
+            installed: true,
+            version: skseVersion,
+            source: "skse.silverlock.org Downloads, read 2026-09-11",
+        });
+    }
+    const pluginsDir = at("Data", "SKSE", "Plugins");
+    let dlls = [];
+    let versionlibs = [];
+    try {
+        const entries = await fs.readdir(pluginsDir);
+        dlls = entries.filter((e) => e.toLowerCase().endsWith(".dll"));
+        versionlibs = entries.filter((e) => VERSIONLIB_RE.test(e));
+    }
+    catch {
+    }
+    components.push({ id: "skse-plugins", label: "SKSE plugins", kind: "mod", installed: dlls.length > 0, source: dlls.length ? `${dlls.length} .dll under Data/SKSE/Plugins` : undefined, path: pluginsDir });
+    const runtimeParts = gameVersion ? parseVersion(gameVersion)?.numeric : undefined;
+    const matching = runtimeParts && runtimeParts.length >= 3
+        ? versionlibs.find((v) => {
+            const m = VERSIONLIB_RE.exec(v);
+            return m !== null && Number(m[1]) === runtimeParts[0] && Number(m[2]) === runtimeParts[1] && Number(m[3]) === runtimeParts[2];
+        })
+        : undefined;
+    components.push({
+        id: "addresslib",
+        label: "Address Library for SKSE Plugins",
+        kind: "framework",
+        installed: versionlibs.length > 0,
+        version: matching ? gameVersion : undefined,
+        source: versionlibs.length ? `${versionlibs.length} versionlib-*.bin under Data/SKSE/Plugins${matching ? `; ${matching} matches the runtime` : gameVersion ? "; none names the detected runtime" : ""}` : undefined,
+        path: pluginsDir,
+    });
+    components.push({
+        id: "addresslib-missing-for-runtime",
+        label: "Address Library missing for this runtime",
+        kind: "framework",
+        installed: dlls.length > 0 && matching === undefined,
+        source: "derived: SKSE plugins present, no versionlib names this install's runtime",
+    });
+    const crashLogger = path.join(pluginsDir, "CrashLogger.dll");
+    components.push({ id: "crashlogger", label: "Crash Logger SSE", kind: "mod", installed: await pathExists(crashLogger), path: crashLogger });
+    const ck = at("CreationKit.exe");
+    const ckInstalled = await pathExists(ck);
+    components.push({ id: "creationkit", label: "Creation Kit", kind: "tool", installed: ckInstalled, version: ckInstalled ? await readPeFileVersion(ck) : undefined, source: ckInstalled ? "CreationKit.exe (PE FileVersion)" : undefined, path: ck });
+    const mo2 = await findMo2Profile(install);
+    components.push({ id: "mo2", label: "Mod Organizer 2 (instance managing this install)", kind: "tool", installed: mo2 !== undefined, source: mo2 ? `${mo2.iniPath}, profile ${mo2.profileName}` : undefined, path: mo2?.instanceDir });
+    const vortexManifest = await resolveCandidate([at("Data", "vortex.deployment.json")]);
+    components.push({ id: "vortex", label: "Vortex (deployment manifest in Data)", kind: "tool", installed: vortexManifest !== undefined, path: vortexManifest?.path ?? at("Data", "vortex.deployment.json") });
+    return components;
+}
+const RULES = [
+    ...SKSE_BUILDS.map((b) => ({
+        id: `sse-skse-${b.skse.replace(/\./g, "-")}-runtime`,
+        game: "skyrimse",
+        component: `skse-build-${b.skse}`,
+        requires: [{ component: "game", ...b.runtime }],
+        note: `SKSE64 ${b.skse} (${b.label}) is built for game runtime ${b.runtime.exact ?? `${b.runtime.min} to ${b.runtime.max}`} and refuses any other; a game update needs a matching SKSE release.`,
+        source: "https://skse.silverlock.org/ (Downloads, read 2026-09-11); skse64_common/skse_version.h CURRENT_RELEASE_RUNTIME",
+        severity: "block",
+        undeterminedSeverity: "warn",
+    })),
+    {
+        id: "sse-skse-unknown-build",
+        game: "skyrimse",
+        component: "skse-build-unknown",
+        requires: [],
+        advisory: true,
+        severity: "info",
+        note: "This SKSE64 build is not in ModWright's pairing table (2.3.1, 2.2.6, 2.0.20 as of 2026-09-11); check skse.silverlock.org for the runtime it targets.",
+        source: "https://skse.silverlock.org/ (Downloads)",
+    },
+    {
+        id: "sse-skse-no-ms-store",
+        game: "skyrimse",
+        component: "skse",
+        requires: [{ component: "storefront-ms" }],
+        advisory: true,
+        severity: "block",
+        note: "SKSE does not support the Windows Store / Game Pass release of Skyrim; this install's user-data folder is the MS one.",
+        source: "https://skse.silverlock.org/ (Compatibility)",
+    },
+    {
+        id: "sse-skse-no-epic",
+        game: "skyrimse",
+        component: "skse",
+        requires: [{ component: "storefront-epic" }],
+        advisory: true,
+        severity: "block",
+        note: "SKSE does not support the Epic Games Store release of Skyrim, although SKSE's own code carries an EPIC save-folder branch.",
+        source: "https://skse.silverlock.org/ (Compatibility); skse64_common/skse_version.h RUNTIME_TYPE_EPIC",
+    },
+    {
+        id: "sse-addresslib-for-runtime",
+        game: "skyrimse",
+        component: "skse-plugins",
+        requires: [{ component: "addresslib-missing-for-runtime" }],
+        advisory: true,
+        severity: "warn",
+        versionGate: "game",
+        undeterminedSeverity: "info",
+        note: "SKSE plugins are installed but no Address Library versionlib-*.bin matches this install's game runtime (reported at info when the runtime itself could not be read); a version-independent plugin will be disabled with 'address library needs to be updated'.",
+        source: "skse64/PluginManager.cpp CheckAddressLibrary; the 'disabled, address library needs to be updated' rejection",
+    },
+];
+export const skyrimseCompat = {
+    detectComponents,
+    rules: RULES,
+};

package/dist/surfaces/skyrimse/index.js

@@ -0,0 +1,12 @@
+export { skyrimse } from "./surface.js";
+export { SIGNATURES } from "./logs.js";
+export { PLUGIN_VALIDATORS } from "./validators/plugins.js";
+export { ARCHIVE_VALIDATORS } from "./validators/archives.js";
+export { RECORD_VALIDATORS } from "./validators/records.js";
+export { walkPluginRecords, readPluginRecords, classifyRecord, modIndexOf, objectIndexOf, RecordWalkError } from "./records.js";
+export { skyrimseCompat, SKSE_BUILDS } from "./compat.js";
+export { parseBsaHeader, readBsaHeader, BsaHeaderError, parseBsaTable, readBsaTable, bsaTableLength, bsaFolderRecordLength, bsaEntries, tesHash } from "./archives.js";
+export { ARCHIVE_RECORD_VALIDATORS } from "./validators/archive-records.js";
+export { SKYRIM_EPIC_APP_NAMES } from "./surface.js";
+export { parsePluginHeader, readPluginHeader, pluginType, PluginHeaderError } from "./plugins.js";
+export { parsePluginsTxt, readLoadOrder, resolvePluginsTxt, findMo2Profile, storefrontOf, userDataDirs, HARDCODED_PLUGINS } from "./loadorder.js";

package/dist/surfaces/skyrimse/loadorder.js

@@ -0,0 +1,174 @@
+import { existsSync, promises as fs } from "node:fs";
+import * as path from "node:path";
+import { documents, localAppData, pathExists } from "../../core/fsutil.js";
+export const STOREFRONT_FOLDER = {
+    steam: "Skyrim Special Edition",
+    gog: "Skyrim Special Edition GOG",
+    epic: "Skyrim Special Edition EPIC",
+    ms: "Skyrim Special Edition MS",
+};
+export const HARDCODED_PLUGINS = ["Skyrim.esm", "Update.esm", "Dawnguard.esm", "HearthFires.esm", "Dragonborn.esm"];
+export const CCC_FILE = "Skyrim.ccc";
+const WINDOWS_1252 = new TextDecoder("windows-1252");
+export async function storefrontOf(install) {
+    if (install.source === "xbox")
+        return "ms";
+    if (await pathExists(path.join(install.root, "Galaxy64.dll")))
+        return "gog";
+    if (await pathExists(path.join(install.root, "EOSSDK-Win64-Shipping.dll")))
+        return "epic";
+    return "steam";
+}
+export function storefrontOfSync(install) {
+    if (install.source === "xbox")
+        return "ms";
+    if (existsSync(path.join(install.root, "Galaxy64.dll")))
+        return "gog";
+    if (existsSync(path.join(install.root, "EOSSDK-Win64-Shipping.dll")))
+        return "epic";
+    return "steam";
+}
+export async function userDataDirs(install) {
+    const storefront = await storefrontOf(install);
+    const folder = STOREFRONT_FOLDER[storefront];
+    return { storefront, localAppData: localAppData(folder), myGames: documents("My Games", folder) };
+}
+export function parsePluginsTxt(bytes) {
+    const text = WINDOWS_1252.decode(bytes);
+    const byKey = new Map();
+    const order = [];
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const line = raw.replace(/\s+$/, "");
+        if (line.length === 0 || line.startsWith("#"))
+            continue;
+        const enabled = line.startsWith("*");
+        let name = enabled ? line.slice(1) : line;
+        if (name.toLowerCase().endsWith(".ghost"))
+            name = name.slice(0, -".ghost".length);
+        if (name.length === 0)
+            continue;
+        const key = name.toLowerCase();
+        if (byKey.has(key)) {
+            order.splice(order.indexOf(key), 1);
+        }
+        byKey.set(key, { name, enabled, line: i + 1 });
+        order.push(key);
+    }
+    return order.map((k) => byKey.get(k));
+}
+export async function readCcc(root) {
+    const p = path.join(root, CCC_FILE);
+    if (!(await pathExists(p)))
+        return [];
+    const bytes = await fs.readFile(p);
+    return WINDOWS_1252.decode(bytes)
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+}
+export function parseIni(text) {
+    const out = new Map();
+    let section = "";
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith(";") || line.startsWith("#"))
+            continue;
+        const sec = /^\[(.+)\]$/.exec(line);
+        if (sec) {
+            section = sec[1].trim().toLowerCase();
+            continue;
+        }
+        const eq = line.indexOf("=");
+        if (eq < 0)
+            continue;
+        const key = line.slice(0, eq).trim().toLowerCase();
+        let value = line.slice(eq + 1).trim();
+        const wrapped = /^@ByteArray\((.*)\)$/.exec(value);
+        if (wrapped)
+            value = wrapped[1];
+        if (!out.has(section))
+            out.set(section, new Map());
+        out.get(section).set(key, value);
+    }
+    return out;
+}
+function samePath(a, b) {
+    const norm = (p) => path.resolve(p.replace(/\\\\/g, "\\")).replace(/[\\/]+$/, "").toLowerCase();
+    return norm(a) === norm(b);
+}
+export async function findMo2Profile(install, instancesRoot = localAppData("ModOrganizer")) {
+    if (!(await pathExists(instancesRoot)))
+        return undefined;
+    let entries;
+    try {
+        entries = await fs.readdir(instancesRoot);
+    }
+    catch {
+        return undefined;
+    }
+    for (const name of entries) {
+        const instanceDir = path.join(instancesRoot, name);
+        const iniPath = path.join(instanceDir, "ModOrganizer.ini");
+        if (!(await pathExists(iniPath)))
+            continue;
+        let ini;
+        try {
+            ini = parseIni(await fs.readFile(iniPath, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const general = ini.get("general");
+        const settings = ini.get("settings");
+        const gamePath = general?.get("gamepath");
+        if (!gamePath || !samePath(gamePath, install.root))
+            continue;
+        const profileName = general?.get("selected_profile") ?? "Default";
+        const base = settings?.get("base_directory") ?? instanceDir;
+        const profilesDir = (settings?.get("profiles_directory") ?? "%BASE_DIR%/profiles").replace(/%BASE_DIR%/gi, base);
+        const profileDir = path.join(profilesDir, profileName);
+        const pluginsTxt = path.join(profileDir, "plugins.txt");
+        if (!(await pathExists(pluginsTxt)))
+            continue;
+        return { instanceDir, iniPath, profileName, profileDir, pluginsTxt };
+    }
+    return undefined;
+}
+export async function resolvePluginsTxt(install, options = {}) {
+    if (!options.ignoreMo2) {
+        const mo2 = await findMo2Profile(install, options.mo2InstancesRoot);
+        if (mo2)
+            return { path: mo2.pluginsTxt, from: "mo2-profile", mo2 };
+    }
+    const dirs = { ...(await userDataDirs(install)), ...options.dirs };
+    return { path: path.join(dirs.localAppData, "Plugins.txt"), from: "game" };
+}
+export async function readLoadOrder(install, options = {}) {
+    const source = await resolvePluginsTxt(install, options);
+    const implicit = [...HARDCODED_PLUGINS, ...(await readCcc(install.root))];
+    const seen = new Set(implicit.map((n) => n.toLowerCase()));
+    const listed = [];
+    let fileFound = false;
+    if (await pathExists(source.path)) {
+        fileFound = true;
+        for (const entry of parsePluginsTxt(await fs.readFile(source.path))) {
+            if (seen.has(entry.name.toLowerCase()))
+                continue;
+            listed.push(entry);
+        }
+    }
+    const dataDir = path.join(install.root, "Data");
+    const entries = [];
+    let index = 0;
+    const push = async (name, enabled) => {
+        const onDisk = await pathExists(path.join(dataDir, name));
+        entries.push({ index: index++, name, enabled, ...(onDisk ? { modId: `plugins:${name}` } : {}) });
+    };
+    for (const name of implicit)
+        await push(name, true);
+    for (const entry of listed)
+        await push(entry.name, entry.enabled);
+    return { entries, source, implicit, fileFound };
+}