modwright 0.1.0

package/dist/core/compat/check.js

@@ -0,0 +1,113 @@
+import { satisfies } from "./version.js";
+export function checkCompat(components, rules) {
+    const byId = new Map(components.map((c) => [c.id, c]));
+    const issues = [];
+    const undetermined = new Set();
+    for (const c of components) {
+        if (c.installed && c.version === undefined)
+            undetermined.add(c.id);
+    }
+    for (const rule of rules) {
+        if (!byId.get(rule.component)?.installed)
+            continue;
+        if (rule.advisory) {
+            evaluateAdvisoryRule(rule, byId, issues);
+            continue;
+        }
+        for (const req of rule.requires) {
+            const required = byId.get(req.component);
+            if (!required?.installed) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity ?? "block",
+                    component: req.component,
+                    message: `${rule.component} requires ${req.component}, which is not installed.`,
+                    hint: rule.note,
+                });
+                continue;
+            }
+            const result = satisfies(required.version, req);
+            if (result === "undetermined") {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.undeterminedSeverity ?? "warn",
+                    component: req.component,
+                    message: `${req.component}'s version could not be determined, so ${rule.component}'s ` +
+                        `requirement on it (${describeRequirement(req)}) could not be checked.`,
+                    hint: rule.note,
+                });
+            }
+            else if (result === "unsatisfied") {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity ?? "block",
+                    component: req.component,
+                    message: `${req.component} ${required.version ?? "?"} does not satisfy ${rule.component}'s ` +
+                        `requirement (${describeRequirement(req)}).`,
+                    hint: rule.note,
+                });
+            }
+        }
+    }
+    const hasBlock = issues.some((i) => i.severity === "block");
+    const hasWarn = issues.some((i) => i.severity === "warn");
+    const status = hasBlock ? "broken" : hasWarn ? "degraded" : "ok";
+    return {
+        game: "",
+        install: "",
+        components,
+        issues,
+        undetermined: [...undetermined].sort(),
+        status,
+        note: summarize(issues, rules.length, components),
+    };
+}
+function evaluateAdvisoryRule(rule, byId, issues) {
+    const allInstalled = rule.requires.every((r) => byId.get(r.component)?.installed);
+    if (!allInstalled)
+        return;
+    const gateKnown = rule.versionGate === undefined || byId.get(rule.versionGate)?.version !== undefined;
+    issues.push({
+        ruleId: rule.id,
+        severity: gateKnown ? rule.severity ?? "warn" : rule.undeterminedSeverity ?? "info",
+        component: rule.component,
+        message: rule.note,
+        hint: rule.source,
+    });
+}
+function describeRequirement(req) {
+    if (req.exact !== undefined)
+        return `exactly ${req.exact}`;
+    const parts = [];
+    if (req.min !== undefined)
+        parts.push(`>= ${req.min}`);
+    if (req.max !== undefined)
+        parts.push(`<= ${req.max}`);
+    return parts.length > 0 ? parts.join(", ") : "installed";
+}
+function summarize(issues, ruleCount, components) {
+    if (issues.length === 0) {
+        const installedCount = components.filter((c) => c.installed).length;
+        return `No incompatibilities found among ${installedCount} detected component(s) against ${ruleCount} rule(s).`;
+    }
+    const blockCount = issues.filter((i) => i.severity === "block").length;
+    const warnCount = issues.filter((i) => i.severity === "warn").length;
+    const infoCount = issues.filter((i) => i.severity === "info").length;
+    return `${blockCount} blocking, ${warnCount} warning, ${infoCount} informational issue(s) across ${ruleCount} rule(s).`;
+}
+export async function runCompat(surface, install) {
+    if (!surface.compat) {
+        return {
+            game: surface.id,
+            install: install.root,
+            components: [],
+            issues: [],
+            undetermined: [],
+            status: "unknown",
+            note: `${surface.name} has no compatibility checks implemented yet.`,
+        };
+    }
+    const components = await surface.compat.detectComponents(install);
+    const report = checkCompat(components, surface.compat.rules);
+    return { ...report, game: surface.id, install: install.root };
+}

package/dist/core/compat/pe.js

@@ -0,0 +1,220 @@
+import { promises as fs } from "node:fs";
+const DOS_MAGIC = 0x5a4d;
+const PE_SIGNATURE = 0x00004550;
+const RT_VERSION = 16;
+const VS_FIXEDFILEINFO_SIGNATURE = 0xfeef04bd;
+const MAX_SECTIONS = 96;
+const MAX_RESOURCE_ENTRIES = 1024;
+const MAX_VERSIONINFO_BYTES = 1_000_000;
+export async function readPeFileVersion(filePath) {
+    let handle;
+    try {
+        handle = await fs.open(filePath, "r");
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return await readVersion(handle);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await handle.close();
+    }
+}
+export const PE_MACHINE_AMD64 = 0x8664;
+export const PE_MACHINE_I386 = 0x014c;
+const PE32_MAGIC = 0x10b;
+const PE32_PLUS_MAGIC = 0x20b;
+const MAX_EXPORT_NAMES = 65_536;
+const MAX_EXPORT_NAME_BYTES = 1024;
+export async function readPeImageInfo(filePath) {
+    let handle;
+    try {
+        handle = await fs.open(filePath, "r");
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return await readImageInfo(handle);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function readImageInfo(handle) {
+    const dos = await readRange(handle, 0, 64);
+    if (dos.readUInt16LE(0) !== DOS_MAGIC)
+        return undefined;
+    const peOffset = dos.readUInt32LE(0x3c);
+    const coff = await readRange(handle, peOffset, 24);
+    if (coff.readUInt32LE(0) !== PE_SIGNATURE)
+        return undefined;
+    const machine = coff.readUInt16LE(4);
+    const numberOfSections = coff.readUInt16LE(6);
+    const sizeOfOptionalHeader = coff.readUInt16LE(20);
+    if (numberOfSections <= 0 || numberOfSections > MAX_SECTIONS || sizeOfOptionalHeader < 2)
+        return undefined;
+    const optional = await readRange(handle, peOffset + 24, sizeOfOptionalHeader);
+    const magic = optional.readUInt16LE(0);
+    if (magic !== PE32_MAGIC && magic !== PE32_PLUS_MAGIC)
+        return undefined;
+    const pe32Plus = magic === PE32_PLUS_MAGIC;
+    const rvaCountAt = pe32Plus ? 108 : 92;
+    const dirsAt = pe32Plus ? 112 : 96;
+    if (sizeOfOptionalHeader < dirsAt + 8)
+        return { machine, pe32Plus, exports: [] };
+    const numberOfRvaAndSizes = optional.readUInt32LE(rvaCountAt);
+    const exportRva = numberOfRvaAndSizes > 0 ? optional.readUInt32LE(dirsAt) : 0;
+    const exportSize = numberOfRvaAndSizes > 0 ? optional.readUInt32LE(dirsAt + 4) : 0;
+    if (exportRva === 0 || exportSize === 0)
+        return { machine, pe32Plus, exports: [] };
+    const sectionTable = await readRange(handle, peOffset + 24 + sizeOfOptionalHeader, numberOfSections * 40);
+    const rvaToFile = (rva) => {
+        for (let i = 0; i < numberOfSections; i++) {
+            const entry = sectionTable.subarray(i * 40, i * 40 + 40);
+            const virtualSize = entry.readUInt32LE(8);
+            const virtualAddress = entry.readUInt32LE(12);
+            const sizeOfRawData = entry.readUInt32LE(16);
+            const pointerToRawData = entry.readUInt32LE(20);
+            const span = Math.max(virtualSize, sizeOfRawData);
+            if (rva >= virtualAddress && rva < virtualAddress + span)
+                return rva - virtualAddress + pointerToRawData;
+        }
+        return undefined;
+    };
+    const dirAt = rvaToFile(exportRva);
+    if (dirAt === undefined)
+        return undefined;
+    const dir = await readRange(handle, dirAt, 40);
+    const numberOfNames = dir.readUInt32LE(24);
+    const addressOfNames = dir.readUInt32LE(32);
+    if (numberOfNames === 0)
+        return { machine, pe32Plus, exports: [] };
+    if (numberOfNames > MAX_EXPORT_NAMES)
+        return undefined;
+    const namesAt = rvaToFile(addressOfNames);
+    if (namesAt === undefined)
+        return undefined;
+    const nameRvas = await readRange(handle, namesAt, numberOfNames * 4);
+    const exports = [];
+    for (let i = 0; i < numberOfNames; i++) {
+        const nameAt = rvaToFile(nameRvas.readUInt32LE(i * 4));
+        if (nameAt === undefined)
+            return undefined;
+        const buffer = Buffer.alloc(MAX_EXPORT_NAME_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, MAX_EXPORT_NAME_BYTES, nameAt);
+        const end = buffer.subarray(0, bytesRead).indexOf(0);
+        if (end <= 0)
+            return undefined;
+        exports.push(buffer.subarray(0, end).toString("latin1"));
+    }
+    return { machine, pe32Plus, exports };
+}
+async function readRange(handle, offset, length) {
+    if (offset < 0 || length <= 0)
+        throw new RangeError("invalid range");
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, offset);
+    if (bytesRead < length)
+        throw new RangeError("short read");
+    return buffer;
+}
+async function readVersion(handle) {
+    const dos = await readRange(handle, 0, 64);
+    if (dos.readUInt16LE(0) !== DOS_MAGIC)
+        return undefined;
+    const peOffset = dos.readUInt32LE(0x3c);
+    const coff = await readRange(handle, peOffset, 24);
+    if (coff.readUInt32LE(0) !== PE_SIGNATURE)
+        return undefined;
+    const numberOfSections = coff.readUInt16LE(6);
+    const sizeOfOptionalHeader = coff.readUInt16LE(20);
+    if (numberOfSections <= 0 || numberOfSections > MAX_SECTIONS)
+        return undefined;
+    const sectionTableOffset = peOffset + 24 + sizeOfOptionalHeader;
+    const sectionTable = await readRange(handle, sectionTableOffset, numberOfSections * 40);
+    const rsrc = findRsrcSection(sectionTable, numberOfSections);
+    if (!rsrc)
+        return undefined;
+    return readVersionFromRsrc(handle, rsrc);
+}
+function findRsrcSection(sectionTable, numberOfSections) {
+    for (let i = 0; i < numberOfSections; i++) {
+        const entry = sectionTable.subarray(i * 40, i * 40 + 40);
+        const name = entry.subarray(0, 8).toString("latin1").replace(/\0+$/, "");
+        if (name === ".rsrc") {
+            return {
+                virtualAddress: entry.readUInt32LE(12),
+                pointerToRawData: entry.readUInt32LE(20),
+            };
+        }
+    }
+    return undefined;
+}
+async function readVersionFromRsrc(handle, rsrc) {
+    const dirOffsetToFile = (relativeOffset) => rsrc.pointerToRawData + relativeOffset;
+    const rvaToFile = (rva) => rva - rsrc.virtualAddress + rsrc.pointerToRawData;
+    const versionEntry = await findEntryById(handle, dirOffsetToFile(0), RT_VERSION);
+    if (versionEntry === undefined)
+        return undefined;
+    const nameDirOffset = dirOffsetToFile(versionEntry & 0x7fffffff);
+    const nameEntry = await findFirstEntry(handle, nameDirOffset);
+    if (nameEntry === undefined)
+        return undefined;
+    const langDirOffset = dirOffsetToFile(nameEntry & 0x7fffffff);
+    const langEntry = await findFirstEntry(handle, langDirOffset);
+    if (langEntry === undefined || (langEntry & 0x80000000) !== 0)
+        return undefined;
+    const dataEntry = await readRange(handle, dirOffsetToFile(langEntry), 16);
+    const dataRva = dataEntry.readUInt32LE(0);
+    const dataSize = dataEntry.readUInt32LE(4);
+    if (dataSize <= 0 || dataSize > MAX_VERSIONINFO_BYTES)
+        return undefined;
+    const payload = await readRange(handle, rvaToFile(dataRva), dataSize);
+    return extractFixedFileInfoVersion(payload);
+}
+async function findEntryById(handle, offset, id) {
+    const header = await readRange(handle, offset, 16);
+    const namedCount = header.readUInt16LE(12);
+    const idCount = header.readUInt16LE(14);
+    const total = namedCount + idCount;
+    if (total <= 0 || total > MAX_RESOURCE_ENTRIES)
+        return undefined;
+    const entries = await readRange(handle, offset + 16, total * 8);
+    for (let i = namedCount; i < total; i++) {
+        const entry = entries.subarray(i * 8, i * 8 + 8);
+        if (entry.readUInt32LE(0) === id)
+            return entry.readUInt32LE(4);
+    }
+    return undefined;
+}
+async function findFirstEntry(handle, offset) {
+    const header = await readRange(handle, offset, 16);
+    const namedCount = header.readUInt16LE(12);
+    const idCount = header.readUInt16LE(14);
+    if (namedCount + idCount <= 0)
+        return undefined;
+    const entry = await readRange(handle, offset + 16, 8);
+    return entry.readUInt32LE(4);
+}
+function extractFixedFileInfoVersion(payload) {
+    for (let offset = 0; offset + 16 <= payload.length; offset += 4) {
+        if (payload.readUInt32LE(offset) !== VS_FIXEDFILEINFO_SIGNATURE)
+            continue;
+        const ms = payload.readUInt32LE(offset + 8);
+        const ls = payload.readUInt32LE(offset + 12);
+        const major = ms >>> 16;
+        const minor = ms & 0xffff;
+        const build = ls >>> 16;
+        const revision = ls & 0xffff;
+        return `${major}.${minor}.${build}.${revision}`;
+    }
+    return undefined;
+}

package/dist/core/compat/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/compat/version.js

@@ -0,0 +1,70 @@
+const VERSION_PATTERN = /^\s*[vV]?(\d+(?:\.\d+)*)(.*)$/;
+export function parseVersion(s) {
+    const match = VERSION_PATTERN.exec(s);
+    if (!match)
+        return undefined;
+    const numericPart = match[1];
+    const rest = match[2] ?? "";
+    if (!numericPart)
+        return undefined;
+    const numeric = numericPart.split(".").map((piece) => Number.parseInt(piece, 10));
+    if (numeric.length === 0 || numeric.some((n) => Number.isNaN(n)))
+        return undefined;
+    return { raw: s, numeric, suffix: rest.trim() };
+}
+export function isDifferentVersionAxis(a, b) {
+    const pa = parseVersion(a);
+    const pb = parseVersion(b);
+    if (!pa || !pb)
+        return false;
+    return pa.numeric.length !== pb.numeric.length;
+}
+function compareParsed(a, b) {
+    const length = Math.max(a.numeric.length, b.numeric.length);
+    for (let i = 0; i < length; i++) {
+        const na = a.numeric[i] ?? 0;
+        const nb = b.numeric[i] ?? 0;
+        if (na !== nb)
+            return na < nb ? -1 : 1;
+    }
+    return 0;
+}
+export function compareVersions(a, b) {
+    const pa = parseVersion(a);
+    const pb = parseVersion(b);
+    if (!pa || !pb) {
+        throw new RangeError(`compareVersions: not a comparable version ("${a}" vs "${b}")`);
+    }
+    return compareParsed(pa, pb);
+}
+export function satisfies(version, req) {
+    const hasConstraint = req.min !== undefined || req.max !== undefined || req.exact !== undefined;
+    if (!hasConstraint)
+        return "satisfied";
+    if (version === undefined)
+        return "undetermined";
+    const v = parseVersion(version);
+    if (!v)
+        return "undetermined";
+    if (req.exact !== undefined) {
+        const exact = parseVersion(req.exact);
+        if (!exact)
+            return "undetermined";
+        return compareParsed(v, exact) === 0 ? "satisfied" : "unsatisfied";
+    }
+    if (req.min !== undefined) {
+        const min = parseVersion(req.min);
+        if (!min)
+            return "undetermined";
+        if (compareParsed(v, min) < 0)
+            return "unsatisfied";
+    }
+    if (req.max !== undefined) {
+        const max = parseVersion(req.max);
+        if (!max)
+            return "undetermined";
+        if (compareParsed(v, max) > 0)
+            return "unsatisfied";
+    }
+    return "satisfied";
+}