modwright 0.1.0

package/dist/core/text/converters/index.js

@@ -0,0 +1,261 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { assertAbsolute, runTool } from "../../toolchain/run.js";
+import { planFile, executePlan } from "../../safety/index.js";
+import { fieldDiff } from "../diff/index.js";
+import { renumberHandles } from "../handles.js";
+import { parseJson } from "../json.js";
+import { defaultLocateTool } from "../toolchain.js";
+import { BG3_CONVERTERS } from "./bg3.js";
+import { CYBERPUNK_CONVERTERS } from "./cyberpunk.js";
+export { BG3_CONVERTERS } from "./bg3.js";
+export { CYBERPUNK_CONVERTERS } from "./cyberpunk.js";
+export const CONVERTERS = [...BG3_CONVERTERS, ...CYBERPUNK_CONVERTERS];
+const BY_ID = new Map(CONVERTERS.map((c) => [c.id, c]));
+export function getConverter(id) {
+    const entry = BY_ID.get(id);
+    if (!entry) {
+        throw new Error(`text convert: unknown conversion id "${id}". Known: ${CONVERTERS.map((c) => c.id).join(", ")}`);
+    }
+    return entry;
+}
+function scratchExt(kindLabel) {
+    return kindLabel.startsWith(".") ? kindLabel : ".bin";
+}
+async function pathExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function soleFileIn(dir, expectedName) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = entries.filter((e) => e.isFile()).map((e) => e.name);
+    if (files.length === 1)
+        return path.join(dir, files[0]);
+    if (files.length === 0) {
+        throw new Error(`no output file found in ${dir} (expected "${expectedName}")`);
+    }
+    throw new Error(`ambiguous output in ${dir}: expected "${expectedName}" but found ${files.length} files (${files.join(", ")})`);
+}
+function destinationArg(entry, destAbs) {
+    return entry.destinationKind === "output-directory" ? path.dirname(destAbs) : destAbs;
+}
+async function runConverterTool(entry, sourceAbs, targetAbs, location, tmpRoot) {
+    if (entry.destinationKind === "output-directory") {
+        await fs.mkdir(tmpRoot, { recursive: true });
+        const outDir = await fs.mkdtemp(path.join(tmpRoot, "modwright-convert-"));
+        const cleanup = async () => {
+            await fs.rm(outDir, { recursive: true, force: true }).catch(() => { });
+        };
+        const argv = entry.argv(sourceAbs, outDir);
+        const result = await runTool(location, { args: argv });
+        if (!result.ok) {
+            return { argv, ok: false, errorMessage: result.error?.message ?? `exit ${result.exitCode}`, cleanup };
+        }
+        const expectedName = entry.expectedOutputName ? entry.expectedOutputName(sourceAbs) : path.basename(targetAbs);
+        const expectedPath = path.join(outDir, expectedName);
+        try {
+            const producedAbs = (await pathExists(expectedPath)) ? expectedPath : await soleFileIn(outDir, expectedName);
+            return { argv, ok: true, producedAbs, cleanup };
+        }
+        catch (err) {
+            return { argv, ok: false, errorMessage: err.message, cleanup };
+        }
+    }
+    const argv = entry.argv(sourceAbs, targetAbs);
+    const result = await runTool(location, { args: argv, expectOutputs: [targetAbs] });
+    if (!result.ok) {
+        return { argv, ok: false, errorMessage: result.error?.message ?? `exit ${result.exitCode}` };
+    }
+    return { argv, ok: true, producedAbs: targetAbs };
+}
+async function runRoundTrip(entry, originalSourceAbs, producedAbs, entryLocation, locateTool, workDir) {
+    const inverse = getConverter(entry.inverse);
+    const inverseLocation = await locateTool(inverse.toolId);
+    if (!inverseLocation.found) {
+        return {
+            ran: false,
+            skippedReason: `round-trip verification needs ${inverse.toolId}, which was not found: ${inverseLocation.hint ?? "not located"}`,
+        };
+    }
+    const backTarget = path.join(workDir, `roundtrip-back${scratchExt(inverse.to)}`);
+    const inverseOutcome = await runConverterTool(inverse, producedAbs, backTarget, inverseLocation, workDir);
+    if (!inverseOutcome.ok) {
+        await inverseOutcome.cleanup?.();
+        return { ran: true, ok: false, skippedReason: `round-trip conversion (${inverse.id}) failed: ${inverseOutcome.errorMessage}` };
+    }
+    const backAbs = inverseOutcome.producedAbs;
+    if (entry.roundTrip === "forward-and-byte-compare") {
+        const backBytes = await fs.readFile(backAbs);
+        const originalBytes = await fs.readFile(originalSourceAbs);
+        const bytesMatch = backBytes.equals(originalBytes);
+        if (bytesMatch) {
+            await inverseOutcome.cleanup?.();
+            return { ran: true, ok: true, bytesMatch, note: "byte compare: round-tripped binary is byte-identical to the original." };
+        }
+        const diffKind = inverse.diffKind;
+        if (!diffKind) {
+            await inverseOutcome.cleanup?.();
+            return {
+                ran: true,
+                ok: false,
+                bytesMatch,
+                note: "byte compare failed and no field-diff kind is registered for this format, so semantic equivalence could not be checked.",
+            };
+        }
+        const secondTextTarget = path.join(workDir, `roundtrip-second${scratchExt(entry.to)}`);
+        const secondOutcome = await runConverterTool(entry, backAbs, secondTextTarget, entryLocation, workDir);
+        if (!secondOutcome.ok) {
+            await inverseOutcome.cleanup?.();
+            await secondOutcome.cleanup?.();
+            return {
+                ran: true,
+                ok: false,
+                bytesMatch,
+                note: `byte compare failed; the semantic check's own re-conversion (${entry.id}) failed too, so semantic equivalence could not be checked: ${secondOutcome.errorMessage}`,
+            };
+        }
+        const firstText = await fs.readFile(producedAbs, "utf8");
+        const secondText = await fs.readFile(secondOutcome.producedAbs, "utf8");
+        await inverseOutcome.cleanup?.();
+        await secondOutcome.cleanup?.();
+        const diff = fieldDiff(diffKind, firstText, secondText);
+        return {
+            ran: true,
+            ok: diff.clean,
+            bytesMatch,
+            semanticMatch: diff.clean,
+            diff: diff.rows,
+            note: diff.clean
+                ? "byte compare failed (non-deterministic binary serialization) but a further conversion field-diffed clean against the first output; treated as a pass."
+                : "byte compare failed and the semantic field diff also found real differences.",
+        };
+    }
+    const originalText = await fs.readFile(originalSourceAbs, "utf8");
+    const roundTrippedText = await fs.readFile(backAbs, "utf8");
+    const diff = fieldDiff(entry.diffKind, originalText, roundTrippedText);
+    await inverseOutcome.cleanup?.();
+    return { ran: true, ok: diff.clean, diff: diff.rows };
+}
+export async function convert(id, sourceAbs, destAbs, options = {}) {
+    const entry = getConverter(id);
+    assertAbsolute([sourceAbs, destAbs]);
+    const mode = options.mode ?? "dry-run";
+    const locateTool = options.locateTool ?? defaultLocateTool();
+    const location = await locateTool(entry.toolId);
+    const renumberNote = entry.id === "cp2077.json-to-cr2w" ? " (HandleId/BufferId renumbered first)" : "";
+    const destNote = entry.destinationKind === "output-directory"
+        ? ` (-o is an output DIRECTORY the tool names its own file in; an apply runs it in a scratch directory and writes the result to ${destAbs})`
+        : "";
+    if (mode === "dry-run") {
+        return {
+            action: "convert",
+            conversionId: entry.id,
+            mode,
+            source: sourceAbs,
+            dest: destAbs,
+            tool: entry.toolId,
+            toolVersion: location.version,
+            argv: entry.argv(sourceAbs, destinationArg(entry, destAbs)),
+            plan: `${entry.describe(sourceAbs, destinationArg(entry, destAbs))}${renumberNote}${destNote}`,
+            applied: false,
+            toolLocation: location,
+            next: 'Nothing was changed. Re-run with { mode: "apply" } to run the tool and write the result; an existing destination is backed up first.',
+        };
+    }
+    if (!location.found) {
+        return {
+            action: "convert",
+            conversionId: entry.id,
+            mode,
+            source: sourceAbs,
+            dest: destAbs,
+            tool: entry.toolId,
+            argv: entry.argv(sourceAbs, destinationArg(entry, destAbs)),
+            applied: false,
+            toolLocation: location,
+            next: location.hint,
+        };
+    }
+    const workDir = await fs.mkdtemp(path.join(os.tmpdir(), "modwright-text-convert-"));
+    try {
+        let actualSourceAbs = sourceAbs;
+        let handleRenumbering;
+        if (entry.id === "cp2077.json-to-cr2w") {
+            const text = await fs.readFile(sourceAbs, "utf8");
+            const parsed = parseJson(text, sourceAbs);
+            const { root, renumbered } = renumberHandles(parsed);
+            handleRenumbering = renumbered.map(({ key, from, to }) => ({ key, from, to }));
+            const renumberDir = path.join(workDir, "renumbered");
+            await fs.mkdir(renumberDir, { recursive: true });
+            actualSourceAbs = path.join(renumberDir, `${path.basename(destAbs)}.json`);
+            await fs.writeFile(actualSourceAbs, JSON.stringify(root));
+        }
+        const scratchDest = path.join(workDir, `produced${scratchExt(entry.to)}`);
+        const runOutcome = await runConverterTool(entry, actualSourceAbs, scratchDest, location, workDir);
+        const argvUsed = runOutcome.argv;
+        if (!runOutcome.ok) {
+            await runOutcome.cleanup?.();
+            return {
+                action: "convert",
+                conversionId: entry.id,
+                mode,
+                source: sourceAbs,
+                dest: destAbs,
+                tool: entry.toolId,
+                toolVersion: location.version,
+                argv: argvUsed,
+                applied: false,
+                handleRenumbering,
+                toolLocation: location,
+                next: `${entry.toolId} failed: ${runOutcome.errorMessage}`,
+            };
+        }
+        const producedAbs = runOutcome.producedAbs;
+        const content = await fs.readFile(producedAbs);
+        const plan = {
+            purpose: `text convert ${entry.id}: ${path.basename(sourceAbs)} -> ${path.basename(destAbs)}`,
+            operations: [planFile(destAbs, content)],
+            backupRoot: path.join(path.dirname(destAbs), ".modwright", "backups"),
+        };
+        const writeReport = await executePlan(plan, {
+            mode: "apply",
+            confidence: {
+                level: "medium",
+                assumptions: [
+                    `${entry.toolId}'s argv shape for this conversion follows ${entry.describe("<source>", "<dest>")}; ` +
+                        "both CR2W directions' argv were checked against the real WolvenKit CLI, " +
+                        "but the produced file's own name is only confirmed for `convert serialize`.",
+                ],
+            },
+        });
+        let roundTrip;
+        if (options.verifyRoundTrip !== false) {
+            roundTrip = await runRoundTrip(entry, sourceAbs, producedAbs, location, locateTool, workDir);
+        }
+        await runOutcome.cleanup?.();
+        return {
+            action: "convert",
+            conversionId: entry.id,
+            mode,
+            source: sourceAbs,
+            dest: destAbs,
+            tool: entry.toolId,
+            toolVersion: location.version,
+            argv: argvUsed,
+            applied: writeReport.applied,
+            handleRenumbering,
+            roundTrip,
+            toolLocation: location,
+            next: writeReport.next,
+        };
+    }
+    finally {
+        await fs.rm(workDir, { recursive: true, force: true });
+    }
+}

package/dist/core/text/diff/cr2w.js

@@ -0,0 +1,180 @@
+import { dollarType, dollarValue, isJsonArray, isJsonObject } from "../json.js";
+const DOCUMENT_LEVEL_FIELDS = ["Data.Version", "Data.BuildVersion", "Data.RootChunk.cookingPlatform", "cookingPlatform"];
+const IGNORED_EXACT_PATHS = new Set([
+    "$.Header.ExportedDateTime",
+    "$.Header.ArchiveFileName",
+    ...DOCUMENT_LEVEL_FIELDS.map((f) => `$.${f}`),
+]);
+const IGNORED_KEY_SEGMENTS = new Set(["renderResourceBlob", "parameters"]);
+const IGNORED_KEY_NAMES = new Set(["HandleId", "BufferId"]);
+function lastSegmentIsIgnored(path) {
+    for (const seg of IGNORED_KEY_SEGMENTS) {
+        if (path === `$.${seg}` || path.endsWith(`.${seg}`) || path.includes(`.${seg}.`) || path.includes(`.${seg}[`)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isIgnoredPath(path) {
+    return IGNORED_EXACT_PATHS.has(path) || lastSegmentIsIgnored(path);
+}
+function normalizeResourceLike(s) {
+    return s.replace(/\//g, "\\").replace(/^\\+/, "").toLowerCase();
+}
+const RELATIVE_EPSILON = 1e-6;
+function scalarsEqual(type, left, right) {
+    if (left === right)
+        return true;
+    if (left === undefined || right === undefined)
+        return false;
+    if (typeof left === "number" && typeof right === "number") {
+        if (type === "Float" || type === "Double" || (!Number.isInteger(left) && !Number.isInteger(right))) {
+            const denom = Math.max(Math.abs(left), Math.abs(right), 1);
+            return Math.abs(left - right) / denom <= RELATIVE_EPSILON;
+        }
+        return left === right;
+    }
+    if (typeof left === "string" && typeof right === "string") {
+        if (type === "CName" || type === "ResourcePath") {
+            return normalizeResourceLike(left) === normalizeResourceLike(right);
+        }
+        return left === right;
+    }
+    return false;
+}
+function handleElementIdentity(el) {
+    if (!isJsonObject(el) || !("Data" in el))
+        return undefined;
+    const data = el.Data;
+    if (!isJsonObject(data))
+        return `handle:${dollarType(data) ?? ""}`;
+    const type = dollarType(data) ?? (typeof data.$type === "string" ? data.$type : "");
+    const nameField = data.name ?? data.appearanceName ?? data.debugName;
+    const name = typeof nameField === "string" ? nameField : dollarValue(nameField);
+    return `handle:${type}:${typeof name === "string" ? name : ""}`;
+}
+function pairArrayElements(left, right) {
+    const leftKeyed = left.map((value, index) => ({ key: handleElementIdentity(value) ?? `#${index}`, index, value }));
+    const rightKeyed = right.map((value, index) => ({ key: handleElementIdentity(value) ?? `#${index}`, index, value }));
+    const usePosition = leftKeyed.some((k) => k.key.startsWith("#")) || rightKeyed.some((k) => k.key.startsWith("#"));
+    if (usePosition) {
+        const len = Math.max(left.length, right.length);
+        const out = [];
+        for (let i = 0; i < len; i++) {
+            out.push({ path: `[${i}]`, l: leftKeyed[i], r: rightKeyed[i] });
+        }
+        return out;
+    }
+    const rightByKey = new Map();
+    for (const k of rightKeyed) {
+        const list = rightByKey.get(k.key) ?? [];
+        list.push(k);
+        rightByKey.set(k.key, list);
+    }
+    const consumed = new Set();
+    const out = [];
+    for (const l of leftKeyed) {
+        const candidates = rightByKey.get(l.key) ?? [];
+        const match = candidates.find((c) => !consumed.has(c));
+        if (match) {
+            consumed.add(match);
+            out.push({ path: `[key:${l.key}]`, l, r: match });
+        }
+        else {
+            out.push({ path: `[key:${l.key}]`, l, r: undefined });
+        }
+    }
+    for (const r of rightKeyed) {
+        if (!consumed.has(r))
+            out.push({ path: `[key:${r.key}]`, l: undefined, r });
+    }
+    return out;
+}
+function pushDocumentLevelFieldDiffs(left, right, rows) {
+    for (const field of DOCUMENT_LEVEL_FIELDS) {
+        const l = getByDotPath(left, field);
+        const r = getByDotPath(right, field);
+        if (l === undefined && r === undefined)
+            continue;
+        if (JSON.stringify(l) !== JSON.stringify(r)) {
+            rows.push({
+                path: `$.${field}`,
+                kind: "changed",
+                left: l,
+                right: r,
+                note: "tool-version field, reported once at the document level rather than per node",
+            });
+            return;
+        }
+    }
+}
+function getByDotPath(root, dotPath) {
+    let cur = root;
+    for (const seg of dotPath.split(".")) {
+        if (!isJsonObject(cur))
+            return undefined;
+        cur = cur[seg];
+    }
+    return cur;
+}
+function compareNode(left, right, path, rows) {
+    if (isIgnoredPath(path))
+        return;
+    const parentKey = path.split(/[.[]/).pop()?.replace(/\]$/, "");
+    if (parentKey && IGNORED_KEY_NAMES.has(parentKey))
+        return;
+    if (left === undefined && right === undefined)
+        return;
+    if (left === undefined) {
+        rows.push({ path, kind: "added", right });
+        return;
+    }
+    if (right === undefined) {
+        rows.push({ path, kind: "removed", left });
+        return;
+    }
+    const leftIsTypedScalar = isJsonObject(left) && "$value" in left;
+    const rightIsTypedScalar = isJsonObject(right) && "$value" in right;
+    if (leftIsTypedScalar || rightIsTypedScalar) {
+        const type = dollarType(left) ?? dollarType(right);
+        const lv = dollarValue(left);
+        const rv = dollarValue(right);
+        if (!scalarsEqual(type, lv, rv)) {
+            rows.push({ path, kind: "changed", left: lv, right: rv });
+        }
+        return;
+    }
+    if (isJsonArray(left) && isJsonArray(right)) {
+        for (const { path: sub, l, r } of pairArrayElements(left, right)) {
+            compareNode(l?.value, r?.value, `${path}${sub}`, rows);
+        }
+        return;
+    }
+    if (isJsonArray(left) !== isJsonArray(right)) {
+        rows.push({ path, kind: "changed", left, right });
+        return;
+    }
+    if (isJsonObject(left) && isJsonObject(right)) {
+        const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+        for (const key of keys) {
+            if (IGNORED_KEY_NAMES.has(key))
+                continue;
+            compareNode(left[key], right[key], `${path}.${key}`, rows);
+        }
+        return;
+    }
+    if (!scalarsEqual(undefined, left, right)) {
+        rows.push({ path, kind: "changed", left, right });
+    }
+}
+export function diffCr2wJson(left, right) {
+    const rows = [];
+    pushDocumentLevelFieldDiffs(left, right, rows);
+    compareNode(left, right, "$", rows);
+    return { rows, clean: rows.length === 0 };
+}
+export function diffCr2wJsonText(leftText, rightText) {
+    const left = JSON.parse(leftText);
+    const right = JSON.parse(rightText);
+    return diffCr2wJson(left, right);
+}

package/dist/core/text/diff/index.js

@@ -0,0 +1,16 @@
+import { diffCr2wJsonText } from "./cr2w.js";
+import { diffLocaXml } from "./loca.js";
+import { diffLsx } from "./lsx.js";
+export { diffCr2wJson, diffCr2wJsonText } from "./cr2w.js";
+export { diffLocaXml, diffLocaEntries, parseLocaXml } from "./loca.js";
+export { diffLsx } from "./lsx.js";
+export function fieldDiff(kind, leftText, rightText) {
+    switch (kind) {
+        case "cr2w-json":
+            return diffCr2wJsonText(leftText, rightText);
+        case "lsx":
+            return diffLsx(leftText, rightText);
+        case "loca-xml":
+            return diffLocaXml(leftText, rightText);
+    }
+}

package/dist/core/text/diff/loca.js

@@ -0,0 +1,43 @@
+import { findAll, parseXml } from "../xml.js";
+export function parseLocaXml(xml) {
+    const root = parseXml(xml);
+    return findAll(root, "content").map((el) => ({
+        contentuid: el.attrs.contentuid ?? "",
+        version: el.attrs.version ?? "1",
+        text: el.text,
+    }));
+}
+function key(e) {
+    return e.contentuid;
+}
+export function diffLocaEntries(left, right) {
+    const rows = [];
+    const rightByKey = new Map(right.map((e) => [key(e), e]));
+    const seen = new Set();
+    for (const l of left) {
+        const k = key(l);
+        seen.add(k);
+        const r = rightByKey.get(k);
+        if (!r) {
+            rows.push({ path: `$.content[contentuid=${k}]`, kind: "removed", left: l });
+            continue;
+        }
+        if (l.version !== r.version || l.text !== r.text) {
+            rows.push({
+                path: `$.content[contentuid=${k}]`,
+                kind: "changed",
+                left: { version: l.version, text: l.text },
+                right: { version: r.version, text: r.text },
+            });
+        }
+    }
+    for (const r of right) {
+        const k = key(r);
+        if (!seen.has(k))
+            rows.push({ path: `$.content[contentuid=${k}]`, kind: "added", right: r });
+    }
+    return { rows, clean: rows.length === 0 };
+}
+export function diffLocaXml(leftXml, rightXml) {
+    return diffLocaEntries(parseLocaXml(leftXml), parseLocaXml(rightXml));
+}

package/dist/core/text/diff/lsx.js

@@ -0,0 +1,126 @@
+import { parseXml } from "../xml.js";
+const IGNORED_ATTRIBUTE_IDS = new Set(["FileSize", "MD5"]);
+function attributeChildren(el) {
+    return el.children.filter((c) => c.tag === "attribute");
+}
+function structuralChildren(el, tag) {
+    const out = [];
+    for (const c of el.children) {
+        if (c.tag === tag)
+            out.push(c);
+        else if (c.tag === "children")
+            out.push(...structuralChildren(c, tag));
+    }
+    return out;
+}
+function nodeIdentity(el) {
+    for (const key of ["UUID", "MapKey", "Name"]) {
+        const attr = attributeChildren(el).find((a) => a.attrs.id === key);
+        if (attr)
+            return `${key}=${attr.attrs.value ?? ""}`;
+    }
+    return undefined;
+}
+function segmentFor(tag, el) {
+    const id = el.attrs.id;
+    return id !== undefined ? `${tag}#${id}` : undefined;
+}
+function pairSiblings(tag, left, right) {
+    const groupKey = (el) => segmentFor(tag, el) ?? "#no-id";
+    const leftGroups = new Map();
+    const rightGroups = new Map();
+    for (const el of left) {
+        const k = groupKey(el);
+        (leftGroups.get(k) ?? leftGroups.set(k, []).get(k)).push(el);
+    }
+    for (const el of right) {
+        const k = groupKey(el);
+        (rightGroups.get(k) ?? rightGroups.set(k, []).get(k)).push(el);
+    }
+    const pairs = [];
+    const allKeys = new Set([...leftGroups.keys(), ...rightGroups.keys()]);
+    for (const k of allKeys) {
+        const ls = leftGroups.get(k) ?? [];
+        const rs = rightGroups.get(k) ?? [];
+        const segment = k === "#no-id" ? undefined : k;
+        const multi = ls.length > 1 || rs.length > 1;
+        const anyIdentity = multi && [...ls, ...rs].some((el) => nodeIdentity(el) !== undefined);
+        if (anyIdentity) {
+            const rsByIdentity = new Map(rs.map((el) => [nodeIdentity(el) ?? "#pos", el]));
+            const usedR = new Set();
+            for (const l of ls) {
+                const idn = nodeIdentity(l) ?? "#pos";
+                const r = rsByIdentity.get(idn);
+                if (r)
+                    usedR.add(r);
+                pairs.push({ l, r, segment: segment && idn !== "#pos" ? `${segment}[${idn}]` : segment });
+            }
+            for (const r of rs) {
+                if (usedR.has(r))
+                    continue;
+                const idn = nodeIdentity(r) ?? "#pos";
+                pairs.push({ r, segment: segment && idn !== "#pos" ? `${segment}[${idn}]` : segment });
+            }
+        }
+        else {
+            const len = Math.max(ls.length, rs.length);
+            for (let i = 0; i < len; i++) {
+                pairs.push({ l: ls[i], r: rs[i], segment: multi && segment ? `${segment}[${i}]` : segment });
+            }
+        }
+    }
+    return pairs;
+}
+function compareElements(left, right, path, rows) {
+    if (!left && !right)
+        return;
+    if (!left) {
+        rows.push({ path, kind: "added" });
+        return;
+    }
+    if (!right) {
+        rows.push({ path, kind: "removed" });
+        return;
+    }
+    const leftAttrs = attributeChildren(left);
+    const rightAttrs = attributeChildren(right);
+    const ids = new Set([...leftAttrs.map((a) => a.attrs.id), ...rightAttrs.map((a) => a.attrs.id)]);
+    for (const id of ids) {
+        if (id === undefined || IGNORED_ATTRIBUTE_IDS.has(id))
+            continue;
+        const la = leftAttrs.find((a) => a.attrs.id === id);
+        const ra = rightAttrs.find((a) => a.attrs.id === id);
+        const attrPath = `${path}@${id}`;
+        if (!la) {
+            rows.push({ path: attrPath, kind: "added", right: ra.attrs.value });
+            continue;
+        }
+        if (!ra) {
+            rows.push({ path: attrPath, kind: "removed", left: la.attrs.value });
+            continue;
+        }
+        if (la.attrs.value !== ra.attrs.value) {
+            rows.push({ path: attrPath, kind: "changed", left: la.attrs.value, right: ra.attrs.value });
+        }
+    }
+    for (const tag of ["region", "node"]) {
+        const leftKids = structuralChildren(left, tag);
+        const rightKids = structuralChildren(right, tag);
+        if (leftKids.length === 0 && rightKids.length === 0)
+            continue;
+        const connector = path.split("@")[0].includes("region#") || tag === "node" ? "/" : ".";
+        for (const { l, r, segment } of pairSiblings(tag, leftKids, rightKids)) {
+            const isRootWrapper = tag === "node" && (l ?? r).attrs.id === "root";
+            const childPath = isRootWrapper || !segment ? path : `${path}${connector}${segment}`;
+            compareElements(l, r, childPath, rows);
+        }
+    }
+}
+export function diffLsx(leftXml, rightXml) {
+    const leftRoot = parseXml(leftXml);
+    const rightRoot = parseXml(rightXml);
+    const rootTag = leftRoot.tag !== "#document" ? leftRoot.tag : rightRoot.tag;
+    const rows = [];
+    compareElements(leftRoot, rightRoot, `$.${rootTag}`, rows);
+    return { rows, clean: rows.length === 0 };
+}