modwright 0.1.0

package/dist/surfaces/eldenring/loaders.js

@@ -0,0 +1,132 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { isDirectory, localAppData, pathExists } from "../../core/fsutil.js";
+export const MODENGINE2_CONFIG = "config_eldenring.toml";
+export function me3ProfilesDir() {
+    return localAppData("garyttierney", "me3", "config", "profiles");
+}
+function asRecord(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+export function parseModEngine2Config(text) {
+    const doc = asRecord(parseToml(text));
+    const modengine = asRecord(doc.modengine);
+    const extension = asRecord(doc.extension);
+    const loader = asRecord(extension.mod_loader);
+    const modsRaw = Array.isArray(loader.mods) ? loader.mods : [];
+    const mods = [];
+    for (const raw of modsRaw) {
+        const m = asRecord(raw);
+        if (typeof m.path !== "string")
+            continue;
+        mods.push({ enabled: m.enabled !== false, name: typeof m.name === "string" ? m.name : path.basename(m.path), path: m.path });
+    }
+    const dlls = Array.isArray(modengine.external_dlls) ? modengine.external_dlls.filter((d) => typeof d === "string") : [];
+    return { debug: modengine.debug === true, externalDlls: dlls, looseParams: loader.loose_params === true, mods };
+}
+export const ME3_GAME_IDS = ["darksouls3", "ds3", "sekiro", "sdt", "eldenring", "er", "elden-ring", "armoredcore6", "ac6", "nightreign", "nr", "nightrein"];
+export const ME3_ELDENRING_IDS = ["eldenring", "er", "elden-ring"];
+export const ME3_PROFILE_VERSION = "v1";
+export const ME3_KNOWN_KEYS = {
+    profile: ["profileVersion", "savefile", "start_online", "supports", "packages", "natives", "disable_arxan", "mem_patch", "mem_patch_heap_size", "debug_properties"],
+    supports: ["game", "since"],
+    packages: ["id", "enabled", "path", "load_after", "load_before"],
+    natives: ["path", "optional", "enabled", "load_before", "load_after", "initializer", "finalizer", "load_early"],
+    dependent: ["id", "optional"],
+};
+export function parseMe3ProfileDetailed(text) {
+    const doc = asRecord(parseToml(text));
+    const unknownKeys = [];
+    const supportsWithoutGame = [];
+    const entriesWithoutPath = [];
+    const noteUnknown = (where, record, known) => {
+        for (const key of Object.keys(record))
+            if (!known.includes(key))
+                unknownKeys.push({ where, key });
+    };
+    noteUnknown("profile", doc, ME3_KNOWN_KEYS.profile);
+    const dependents = (raw, where) => {
+        if (!Array.isArray(raw))
+            return undefined;
+        const out = [];
+        raw.forEach((d, i) => {
+            const r = asRecord(d);
+            noteUnknown(`${where}[${i}]`, r, ME3_KNOWN_KEYS.dependent);
+            if (typeof r.id === "string")
+                out.push({ id: r.id, ...(typeof r.optional === "boolean" ? { optional: r.optional } : {}) });
+        });
+        return out;
+    };
+    const list = (block) => {
+        const raw = Array.isArray(doc[block]) ? doc[block] : [];
+        const out = [];
+        raw.forEach((e, index) => {
+            const r = asRecord(e);
+            noteUnknown(`${block}[${index}]`, r, ME3_KNOWN_KEYS[block]);
+            if (typeof r.path !== "string") {
+                entriesWithoutPath.push({ block, index });
+                return;
+            }
+            const entry = { path: r.path };
+            if (typeof r.id === "string")
+                entry.id = r.id;
+            if (typeof r.enabled === "boolean")
+                entry.enabled = r.enabled;
+            if (typeof r.optional === "boolean")
+                entry.optional = r.optional;
+            const after = dependents(r.load_after, `${block}[${index}].load_after`);
+            if (after)
+                entry.loadAfter = after;
+            const before = dependents(r.load_before, `${block}[${index}].load_before`);
+            if (before)
+                entry.loadBefore = before;
+            out.push(entry);
+        });
+        return out;
+    };
+    const supports = [];
+    (Array.isArray(doc.supports) ? doc.supports : []).forEach((s, i) => {
+        const r = asRecord(s);
+        noteUnknown(`supports[${i}]`, r, ME3_KNOWN_KEYS.supports);
+        if (typeof r.game === "string")
+            supports.push(r.game);
+        else
+            supportsWithoutGame.push(i);
+    });
+    const profile = {
+        ...(typeof doc.profileVersion === "string" ? { profileVersion: doc.profileVersion } : {}),
+        ...(typeof doc.savefile === "string" ? { savefile: doc.savefile } : {}),
+        ...(typeof doc.start_online === "boolean" ? { startOnline: doc.start_online } : {}),
+        supports,
+        packages: list("packages"),
+        natives: list("natives"),
+    };
+    return { profile, unknownKeys, supportsWithoutGame, entriesWithoutPath };
+}
+export function parseMe3Profile(text) {
+    return parseMe3ProfileDetailed(text).profile;
+}
+export function gameDir(install) {
+    return path.join(install.root, "Game");
+}
+export function modengine2ModDir(install) {
+    return path.join(gameDir(install), "mod");
+}
+export async function readModEngine2LoadOrder(install) {
+    const configPath = path.join(gameDir(install), MODENGINE2_CONFIG);
+    if (!(await pathExists(configPath)))
+        return { configPath, entries: [] };
+    const config = parseModEngine2Config(await fs.readFile(configPath, "utf8"));
+    const modDir = path.resolve(modengine2ModDir(install)).toLowerCase();
+    const entries = [];
+    let index = 0;
+    for (const mod of config.mods) {
+        const modPath = mod.path.replace(/\\/g, path.sep);
+        const abs = path.isAbsolute(modPath) ? modPath : path.join(gameDir(install), modPath);
+        const inModDir = path.dirname(path.resolve(abs)).toLowerCase() === modDir;
+        const resolves = inModDir && (await isDirectory(abs));
+        entries.push({ index: index++, name: mod.name, enabled: mod.enabled, ...(resolves ? { modId: `modengine2:${path.basename(abs)}` } : {}) });
+    }
+    return { configPath, config, entries };
+}

package/dist/surfaces/eldenring/logs.js

@@ -0,0 +1,67 @@
+const FIXTURE = "test/fixtures/logs/eldenring/real/modengine_2026-03-07.log";
+const PRE = String.raw `^\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\] \[modengine\] `;
+function re(...parts) {
+    return new RegExp(parts.join(""));
+}
+export const SIGNATURES = [
+    {
+        id: "eldenring.modengine2.initializing",
+        game: "eldenring",
+        sources: ["modengine2"],
+        severity: "info",
+        category: "version",
+        pattern: re(PRE, String.raw `\[info\] ModEngine version (?<version>\S+) initializing for Elden Ring`),
+        explain: "Mod Engine 2 started and named its version; the anchor for a run and for compatibility checks.",
+        seenIn: [FIXTURE],
+        extract: ["version"],
+    },
+    {
+        id: "eldenring.modengine2.settings-loaded",
+        game: "eldenring",
+        sources: ["modengine2"],
+        severity: "info",
+        category: "load",
+        pattern: re(PRE, String.raw `\[info\] Local settings loaded: (?<local>true|false), Global settings loaded: (?<global>true|false)`),
+        explain: "Which configuration files Mod Engine 2 found: the per-game config_eldenring.toml (local) and modengine2/config.toml (global). false/false means no configuration at all was read.",
+        hint: "If both are false, config_eldenring.toml is not beside the launcher; nothing in the mods list will load.",
+        seenIn: [FIXTURE],
+        extract: ["local", "global"],
+    },
+    {
+        id: "eldenring.modengine2.dll-load-failed",
+        game: "eldenring",
+        sources: ["modengine2"],
+        severity: "error",
+        category: "load",
+        pattern: re(PRE, String.raw `\[error\] Failed to load DLL (?<path>.+?)\s*$`),
+        explain: "A native (DLL) mod named in external_dlls did not load; the game reports this nowhere else. That mod is absent from the run.",
+        hint: "Check the DLL's own dependencies and that its path is right relative to the launcher; a DLL built for another game version will also fail here.",
+        seenIn: [FIXTURE],
+        extract: ["path"],
+    },
+    {
+        id: "eldenring.modengine2.mod-installed",
+        game: "eldenring",
+        sources: ["modengine2"],
+        severity: "info",
+        category: "order",
+        pattern: re(PRE, String.raw `\[info\] Installing mod location (?<path>.+?)\s*$`),
+        explain: "One line per enabled mod folder the loader installed, so the set of lines is the set of " +
+            "mods actually in the run. Priority is the order of the mods list in config_eldenring.toml " +
+            "(the first enabled entry wins a conflicting file, regulation.bin included); whether these " +
+            "lines are printed in that same order is not confirmed — read the config for the order.",
+        seenIn: [FIXTURE],
+        extract: ["path"],
+    },
+    {
+        id: "eldenring.modengine2.hooks-applied",
+        game: "eldenring",
+        sources: ["modengine2"],
+        severity: "info",
+        category: "success",
+        pattern: re(PRE, String.raw `\[info\] Applied (?<count>\d+) hooks`),
+        explain: "The injection took: the loader hooked the game's asset system.",
+        seenIn: [FIXTURE],
+        extract: ["count"],
+    },
+];

package/dist/surfaces/eldenring/paramdef.js

@@ -0,0 +1,256 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { isDirectory, pathExists } from "../../core/fsutil.js";
+import { parseXml } from "../../core/text/xml.js";
+export const PARAMDEF_TYPES = ["s8", "u8", "s16", "u16", "s32", "u32", "b32", "f32", "angle32", "f64", "fixstr", "fixstrW", "dummy8"];
+export class ParamdefError extends Error {
+    file;
+    constructor(message, file) {
+        super(file ? `${file}: ${message}` : message);
+        this.file = file;
+        this.name = "ParamdefError";
+    }
+}
+const DEF_RE = /^(s8|u8|s16|u16|s32|u32|b32|f32|angle32|f64|fixstr|fixstrW|dummy8)\s+([A-Za-z_][A-Za-z0-9_]*)(?::(\d+))?(?:\[(\d+)\])?(?:\s*=\s*(-?\d+(?:\.\d+)?))?\s*$/;
+export function parseParamdefFieldDef(def) {
+    const m = DEF_RE.exec(def.trim());
+    if (!m)
+        throw new ParamdefError(`field Def "${def}" is not "<type> <name>[:bits][[n]][ = default]" with a known type`);
+    const out = { type: m[1], name: m[2], def: def.trim() };
+    if (m[3] !== undefined)
+        out.bits = Number(m[3]);
+    if (m[4] !== undefined)
+        out.arrayLength = Number(m[4]);
+    if (m[5] !== undefined)
+        out.defaultValue = Number(m[5]);
+    return out;
+}
+function child(el, tag) {
+    return el.children.find((c) => c.tag === tag);
+}
+function childText(el, tag) {
+    const c = child(el, tag);
+    return c ? c.text.trim() : undefined;
+}
+function optionalNumber(el, tag) {
+    const t = childText(el, tag);
+    if (t === undefined || t === "")
+        return undefined;
+    const n = Number(t);
+    return Number.isFinite(n) ? n : undefined;
+}
+export function parseParamdef(xml, file) {
+    const root = parseXml(xml);
+    if (root.tag !== "PARAMDEF")
+        throw new ParamdefError(`root element is <${root.tag}>, not <PARAMDEF>`, file);
+    const paramType = childText(root, "ParamType");
+    if (!paramType)
+        throw new ParamdefError("no <ParamType>", file);
+    const fieldsEl = child(root, "Fields");
+    if (!fieldsEl)
+        throw new ParamdefError("no <Fields>", file);
+    const fields = [];
+    for (const f of fieldsEl.children) {
+        if (f.tag !== "Field")
+            continue;
+        const def = f.attrs.Def;
+        if (def === undefined)
+            throw new ParamdefError("a <Field> has no Def attribute", file);
+        const field = { ...parseParamdefFieldDef(def) };
+        const displayName = childText(f, "DisplayName");
+        if (displayName)
+            field.displayName = displayName;
+        const description = childText(f, "Description");
+        if (description)
+            field.description = description;
+        const enumName = childText(f, "Enum");
+        if (enumName)
+            field.enum = enumName;
+        const minimum = optionalNumber(f, "Minimum");
+        if (minimum !== undefined)
+            field.minimum = minimum;
+        const maximum = optionalNumber(f, "Maximum");
+        if (maximum !== undefined)
+            field.maximum = maximum;
+        const increment = optionalNumber(f, "Increment");
+        if (increment !== undefined)
+            field.increment = increment;
+        const sortId = optionalNumber(f, "SortID");
+        if (sortId !== undefined)
+            field.sortId = sortId;
+        fields.push(field);
+    }
+    const bool = (tag) => (childText(root, tag) ?? "").toLowerCase() === "true";
+    const out = {
+        paramType,
+        dataVersion: optionalNumber(root, "DataVersion") ?? 0,
+        formatVersion: optionalNumber(root, "FormatVersion") ?? 0,
+        bigEndian: bool("BigEndian"),
+        unicode: bool("Unicode"),
+        fields,
+    };
+    if (file)
+        out.file = file;
+    return out;
+}
+export function parseTdf(text, file) {
+    const lines = text
+        .replace(/^/, "")
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    const unquote = (s) => s.replace(/^"(.*)"$/, "$1");
+    if (lines.length < 2)
+        throw new ParamdefError("a tdf needs a name line and a type line", file);
+    const entries = [];
+    for (const line of lines.slice(2)) {
+        const m = /^"([^"]*)"\s*,\s*"?(-?\d+)"?$/.exec(line);
+        if (!m)
+            throw new ParamdefError(`tdf line "${line}" is not "label","value"`, file);
+        entries.push({ label: m[1], value: Number(m[2]) });
+    }
+    return { name: unquote(lines[0]), type: unquote(lines[1]), entries };
+}
+export async function findParamdexGameDir(dir) {
+    for (const candidate of [dir, path.join(dir, "ER")]) {
+        if (await isDirectory(path.join(candidate, "Defs")))
+            return candidate;
+    }
+    return undefined;
+}
+export async function loadParamdex(dir) {
+    const gameDir = await findParamdexGameDir(dir);
+    if (!gameDir)
+        throw new ParamdefError(`no Defs/ directory under ${dir} or ${path.join(dir, "ER")}`);
+    const out = { dir: gameDir, defs: new Map(), byName: new Map(), tdfs: new Map(), problems: [] };
+    const defsDir = path.join(gameDir, "Defs");
+    for (const name of (await fs.readdir(defsDir)).sort()) {
+        if (path.extname(name).toLowerCase() !== ".xml")
+            continue;
+        const file = path.join(defsDir, name);
+        try {
+            const def = parseParamdef(await fs.readFile(file, "utf8"), file);
+            out.defs.set(def.paramType, def);
+            out.byName.set(path.basename(name, path.extname(name)).toLowerCase(), def);
+        }
+        catch (err) {
+            out.problems.push(err.message);
+        }
+    }
+    const tdfsDir = path.join(gameDir, "Tdfs");
+    if (await pathExists(tdfsDir)) {
+        for (const name of (await fs.readdir(tdfsDir)).sort()) {
+            if (path.extname(name).toLowerCase() !== ".tdf")
+                continue;
+            const file = path.join(tdfsDir, name);
+            try {
+                const tdf = parseTdf(await fs.readFile(file, "utf8"), file);
+                out.tdfs.set(tdf.name, tdf);
+            }
+            catch (err) {
+                out.problems.push(err.message);
+            }
+        }
+    }
+    return out;
+}
+export function findParamdef(paramdex, key) {
+    return paramdex.defs.get(key) ?? paramdex.byName.get(key.toLowerCase().replace(/\.xml$/, ""));
+}
+const INT_RANGES = {
+    s8: [-128, 127],
+    u8: [0, 255],
+    s16: [-32768, 32767],
+    u16: [0, 65535],
+    s32: [-2147483648, 2147483647],
+    u32: [0, 4294967295],
+    dummy8: [0, 255],
+};
+const INT_RE = /^-?\d+$/;
+function checkInteger(field, raw) {
+    if (!INT_RE.test(raw))
+        return { kind: "type", message: `"${raw}" is not an integer for ${field.type} ${field.name}` };
+    const n = Number(raw);
+    if (field.bits !== undefined) {
+        const max = 2 ** field.bits - 1;
+        if (n < 0 || n > max)
+            return { kind: "range", message: `${field.name} is a ${field.bits}-bit field (0..${max}); ${raw} does not fit` };
+        return undefined;
+    }
+    const [lo, hi] = INT_RANGES[field.type];
+    if (n < lo || n > hi)
+        return { kind: "range", message: `${raw} is outside ${field.type}'s range ${lo}..${hi} for ${field.name}` };
+    return undefined;
+}
+export function checkFieldValue(field, rawIn, tdfs) {
+    let raw = rawIn.trim();
+    if (field.type === "dummy8" && field.bits !== undefined && field.arrayLength === undefined) {
+        const single = /^\[\s*(-?\d+)\s*\]$/.exec(raw);
+        if (single)
+            raw = single[1];
+    }
+    const isArray = field.arrayLength !== undefined && field.type === "dummy8";
+    if (isArray) {
+        const m = /^\[(.*)\]$/.exec(raw);
+        const parts = (m ? m[1] : raw).split(/[|,\s]+/).filter((p) => p.length > 0);
+        if (parts.length !== field.arrayLength) {
+            return { kind: "array", message: `${field.name} is dummy8[${field.arrayLength}] but the cell "${raw}" has ${parts.length} entr${parts.length === 1 ? "y" : "ies"}` };
+        }
+        for (const p of parts) {
+            if (!INT_RE.test(p) || Number(p) < 0 || Number(p) > 255)
+                return { kind: "array", message: `${field.name}: "${p}" is not a byte (0..255)` };
+        }
+        return undefined;
+    }
+    switch (field.type) {
+        case "s8":
+        case "u8":
+        case "s16":
+        case "u16":
+        case "s32":
+        case "u32":
+        case "dummy8": {
+            const problem = checkInteger(field, raw);
+            if (problem)
+                return problem;
+            break;
+        }
+        case "b32": {
+            if (!/^(0|1|true|false)$/i.test(raw))
+                return { kind: "type", message: `"${raw}" is not a b32 value (0, 1, True or False) for ${field.name}` };
+            break;
+        }
+        case "f32":
+        case "angle32":
+        case "f64": {
+            if (raw === "" || !/^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/.test(raw))
+                return { kind: "type", message: `"${raw}" is not a number for ${field.type} ${field.name}` };
+            const n = Number(raw);
+            if (!Number.isFinite(n))
+                return { kind: "range", message: `"${raw}" is not finite for ${field.type} ${field.name}` };
+            if (field.type !== "f64" && Math.abs(n) > 3.4028235e38)
+                return { kind: "range", message: `${raw} is outside f32's range for ${field.name}` };
+            break;
+        }
+        case "fixstr":
+        case "fixstrW": {
+            const limit = field.arrayLength;
+            const length = field.type === "fixstr" ? Buffer.byteLength(raw, "utf8") : [...raw].length;
+            if (limit !== undefined && length > limit) {
+                return { kind: "range", message: `${field.name} is ${field.type}[${limit}] and "${raw}" is ${length} ${field.type === "fixstr" ? "bytes" : "characters"}` };
+            }
+            return undefined;
+        }
+    }
+    if (field.enum && tdfs) {
+        const tdf = tdfs.get(field.enum);
+        if (tdf) {
+            const n = Number(raw);
+            if (!tdf.entries.some((e) => e.value === n)) {
+                const known = tdf.entries.map((e) => `${e.value}=${e.label}`).join(", ");
+                return { kind: "enum", message: `${field.name} is ${field.enum}; ${raw} is not one of its values (${known})` };
+            }
+        }
+    }
+    return undefined;
+}

package/dist/surfaces/eldenring/params.js

@@ -0,0 +1,129 @@
+import { parseXml } from "../../core/text/xml.js";
+const HEADER_RE = /^ID([^A-Za-z0-9_])Name(?:\1|$)/;
+export function detectCsvDelimiter(firstLine) {
+    const h = HEADER_RE.exec(firstLine);
+    if (h)
+        return h[1];
+    let best = ",";
+    let bestCount = -1;
+    for (const d of [",", ";", "\t"]) {
+        const count = firstLine.split(d).length - 1;
+        if (count > bestCount) {
+            best = d;
+            bestCount = count;
+        }
+    }
+    return best;
+}
+export function parseDsmsCsv(text) {
+    const lines = text.replace(/^/, "").split("\n");
+    const first = (lines.find((l) => l.trim().length > 0) ?? "").replace(/\r$/, "");
+    const delimiter = detectCsvDelimiter(first);
+    const out = { shape: "dsms-csv", delimiter, rows: [] };
+    let sawHeader = false;
+    lines.forEach((rawLine, index) => {
+        const line = rawLine.replace(/\r$/, "");
+        if (line.trim().length === 0)
+            return;
+        const cols = line.split(delimiter);
+        if (!sawHeader && out.rows.length === 0 && HEADER_RE.test(line)) {
+            sawHeader = true;
+            out.fields = cols.slice(2).map((c) => c.trim()).filter((c, i, all) => !(c === "" && i === all.length - 1));
+            return;
+        }
+        const idText = (cols[0] ?? "").trim();
+        const row = { line: index + 1, idText };
+        if (/^-?\d+$/.test(idText))
+            row.id = Number(idText);
+        if (cols.length > 1)
+            row.name = cols[1];
+        const values = cols.slice(2);
+        if (out.fields) {
+            row.cells = new Map();
+            out.fields.forEach((f, i) => {
+                if (i < values.length)
+                    row.cells.set(f, values[i]);
+            });
+            if (values.length !== out.fields.length)
+                row.positional = values;
+        }
+        else {
+            row.positional = values;
+        }
+        out.rows.push(row);
+    });
+    return out;
+}
+function child(el, tag) {
+    return el.children.find((c) => c.tag === tag);
+}
+function num(s) {
+    if (s === undefined || s.trim() === "")
+        return undefined;
+    const n = Number(s);
+    return Number.isFinite(n) ? n : undefined;
+}
+export function isWitchyParamXml(root) {
+    return root.tag === "param" && child(root, "rows") !== undefined;
+}
+export function parseWitchyParamXml(text) {
+    const root = parseXml(text);
+    if (!isWitchyParamXml(root))
+        return undefined;
+    const out = { shape: "witchy-xml", fields: [], rows: [], unreadRows: 0 };
+    const type = child(root, "type")?.text.trim();
+    if (type)
+        out.paramType = type;
+    const paramdef = child(root, "paramdef");
+    if (paramdef) {
+        const t = child(paramdef, "type")?.text.trim();
+        if (t)
+            out.paramdefType = t;
+        const dv = num(child(paramdef, "dataVersion")?.text);
+        if (dv !== undefined)
+            out.dataVersion = dv;
+        const fv = num(child(paramdef, "formatVersion")?.text);
+        if (fv !== undefined)
+            out.formatVersion = fv;
+    }
+    const fieldsEl = child(root, "fields");
+    if (fieldsEl) {
+        for (const f of fieldsEl.children) {
+            if (f.tag !== "field" || !f.attrs.name)
+                continue;
+            const entry = { name: f.attrs.name };
+            if (f.attrs.type)
+                entry.type = f.attrs.type;
+            const al = num(f.attrs.arraylength);
+            if (al !== undefined)
+                entry.arrayLength = al;
+            const bs = num(f.attrs.bitsize);
+            if (bs !== undefined)
+                entry.bitSize = bs;
+            out.fields.push(entry);
+        }
+    }
+    const rowsEl = child(root, "rows");
+    for (const r of rowsEl.children) {
+        if (r.tag !== "row")
+            continue;
+        const idText = (r.attrs.id ?? "").trim();
+        const row = { idText };
+        if (/^-?\d+$/.test(idText))
+            row.id = Number(idText);
+        if (r.attrs.name !== undefined)
+            row.name = r.attrs.name;
+        const cellElements = r.children.filter((c) => c.tag === "field" && c.attrs.name !== undefined);
+        if (cellElements.length > 0) {
+            row.cells = new Map(cellElements.map((c) => [c.attrs.name, c.text]));
+        }
+        else if (r.text.trim().length > 0) {
+            out.unreadRows++;
+        }
+        else {
+            row.cells = new Map(Object.entries(r.attrs).filter(([k]) => k !== "id" && k !== "name" && k !== "paramdexName"));
+        }
+        out.rows.push(row);
+    }
+    return out;
+}