modwright 0.1.0

package/dist/core/logs/scan.js

@@ -0,0 +1,195 @@
+import { promises as fs } from "node:fs";
+const DEFAULT_MAX_LINES = 2000;
+const DEFAULT_MAX_TAIL_BYTES = 8 * 1024 * 1024;
+const LAUNCH_GRACE_MS = 60_000;
+const BRACKET_TIMESTAMP = /^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\]/;
+const BARE_TIMESTAMP = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})/;
+function parseLineTimestamp(line) {
+    const raw = BRACKET_TIMESTAMP.exec(line)?.[1] ?? BARE_TIMESTAMP.exec(line)?.[1];
+    if (!raw)
+        return undefined;
+    const date = new Date(raw.replace(" ", "T"));
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function splitLines(text) {
+    if (text.length === 0)
+        return [];
+    const lines = text.split(/\r\n|\r|\n/);
+    if (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+function buildScanKey(path, birthtimeMs, mtimeMs, size) {
+    return `${path}|${birthtimeMs}|${mtimeMs}|${size}`;
+}
+function parseScanKey(key) {
+    const parts = key.split("|");
+    if (parts.length < 4)
+        return undefined;
+    const size = Number(parts[parts.length - 1]);
+    const mtimeMs = Number(parts[parts.length - 2]);
+    const birthtimeMs = Number(parts[parts.length - 3]);
+    const path = parts.slice(0, parts.length - 3).join("|");
+    if (!path || !Number.isFinite(size) || !Number.isFinite(mtimeMs) || !Number.isFinite(birthtimeMs)) {
+        return undefined;
+    }
+    return { path, birthtimeMs, mtimeMs, size };
+}
+export async function scanSource(source, signatures, scope, ctx) {
+    if (!source.exists) {
+        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [] };
+    }
+    let stat;
+    try {
+        stat = await fs.stat(source.path);
+    }
+    catch {
+        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [] };
+    }
+    const sizeBytes = stat.size;
+    const modifiedAt = stat.mtime;
+    const zeroByte = sizeBytes === 0;
+    const stale = ctx.lastLaunch ? modifiedAt.getTime() < ctx.lastLaunch.getTime() - LAUNCH_GRACE_MS : undefined;
+    const maxLines = scope.maxLines ?? DEFAULT_MAX_LINES;
+    if (source.binary) {
+        const status = {
+            source,
+            sizeBytes,
+            modifiedAt: modifiedAt.toISOString(),
+            zeroByte,
+            linesScanned: 0,
+            endOffset: sizeBytes,
+            findingCount: 0,
+        };
+        if (stale !== undefined)
+            status.stale = stale;
+        return { status, findings: [] };
+    }
+    const birthtimeMs = Math.round(stat.birthtimeMs);
+    const mtimeMs = Math.round(stat.mtimeMs);
+    const key = buildScanKey(source.path, birthtimeMs, mtimeMs, sizeBytes);
+    const requestedOffset = scope.offsets?.[source.id];
+    const hadOffset = requestedOffset !== undefined;
+    let startOffset = requestedOffset ?? 0;
+    let rotated = false;
+    let rewritten = false;
+    if (startOffset > sizeBytes) {
+        rotated = true;
+        startOffset = 0;
+    }
+    const previousKey = scope.offsetKeys?.[source.id];
+    if (hadOffset && previousKey !== undefined && !rotated) {
+        const parsed = parseScanKey(previousKey);
+        if (!parsed) {
+            rotated = true;
+            startOffset = 0;
+        }
+        else if (parsed.path !== source.path || parsed.birthtimeMs !== birthtimeMs) {
+            rotated = true;
+            startOffset = 0;
+        }
+        else if (requestedOffset === sizeBytes && mtimeMs > parsed.mtimeMs) {
+            rotated = true;
+            rewritten = true;
+            startOffset = 0;
+        }
+    }
+    let clipped = false;
+    if ((!hadOffset || rotated) && sizeBytes - startOffset > DEFAULT_MAX_TAIL_BYTES) {
+        startOffset = sizeBytes - DEFAULT_MAX_TAIL_BYTES;
+        clipped = true;
+    }
+    let text = "";
+    const length = sizeBytes - startOffset;
+    if (length > 0) {
+        const handle = await fs.open(source.path, "r");
+        try {
+            const buffer = Buffer.alloc(length);
+            await handle.read(buffer, 0, length, startOffset);
+            text = buffer.toString("utf8");
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    if (startOffset === 0 && text.charCodeAt(0) === 0xfeff)
+        text = text.slice(1);
+    let lines = splitLines(text);
+    if (clipped && lines.length > 0)
+        lines.shift();
+    if ((!hadOffset || rotated) && lines.length > maxLines) {
+        lines = lines.slice(lines.length - maxLines);
+    }
+    const sinceDate = scope.since ? new Date(scope.since) : undefined;
+    let anyTimestampSeen = false;
+    let lastTimestamp;
+    const findingsBySignature = new Map();
+    const findings = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (sinceDate) {
+            const ts = parseLineTimestamp(line);
+            if (ts) {
+                anyTimestampSeen = true;
+                lastTimestamp = ts;
+            }
+            const effective = ts ?? lastTimestamp;
+            if (effective && effective.getTime() < sinceDate.getTime())
+                continue;
+        }
+        for (const sig of signatures) {
+            const match = sig.pattern.exec(line);
+            if (!match)
+                continue;
+            const existing = findingsBySignature.get(sig.id);
+            if (existing) {
+                existing.repeats = (existing.repeats ?? 0) + 1;
+                continue;
+            }
+            const finding = {
+                sourceId: source.id,
+                signatureId: sig.id,
+                severity: sig.severity,
+                category: sig.category,
+                lineNumber: i + 1,
+                line,
+                explain: sig.explain,
+            };
+            if (sig.hint)
+                finding.hint = sig.hint;
+            if (sig.systemImpact === false)
+                finding.systemImpact = false;
+            if (sig.extract?.length && match.groups) {
+                const extracted = {};
+                for (const name of sig.extract) {
+                    const value = match.groups[name];
+                    if (value !== undefined)
+                        extracted[name] = value;
+                }
+                if (Object.keys(extracted).length > 0)
+                    finding.extracted = extracted;
+            }
+            findingsBySignature.set(sig.id, finding);
+            findings.push(finding);
+        }
+    }
+    const status = {
+        source,
+        sizeBytes,
+        modifiedAt: modifiedAt.toISOString(),
+        zeroByte,
+        linesScanned: lines.length,
+        endOffset: sizeBytes,
+        key,
+        findingCount: findings.length,
+    };
+    if (stale !== undefined)
+        status.stale = stale;
+    if (rotated)
+        status.rotated = true;
+    if (rewritten)
+        status.rewritten = true;
+    if (sinceDate && !anyTimestampSeen)
+        status.timestamps = false;
+    return { status, findings };
+}

package/dist/core/logs/triage.js

@@ -0,0 +1,160 @@
+import { promises as fs } from "node:fs";
+import { findRunningProcesses } from "../process.js";
+import { resolveLogs } from "../surfaceutil.js";
+import { scanSource } from "./scan.js";
+const FINDINGS_CAP = 200;
+export async function triageLogs(surface, install, registry, scope = {}) {
+    const sources = await resolveLogs(surface, install);
+    const processResult = await findRunningProcesses(surface.processNames ?? []);
+    const gameRunning = processResult.checked ? processResult.running.length > 0 : undefined;
+    let lastLaunch;
+    let newestModified;
+    for (const source of sources) {
+        if (!source.exists)
+            continue;
+        try {
+            const stat = await fs.stat(source.path);
+            if (!newestModified || stat.mtime > newestModified)
+                newestModified = stat.mtime;
+            if (stat.birthtimeMs > 0 && (!lastLaunch || stat.birthtime > lastLaunch))
+                lastLaunch = stat.birthtime;
+        }
+        catch {
+        }
+    }
+    if (!lastLaunch)
+        lastLaunch = newestModified;
+    let missingReasons = {};
+    if (surface.explainMissing && sources.some((s) => !s.exists)) {
+        try {
+            missingReasons = await surface.explainMissing(install);
+        }
+        catch {
+        }
+    }
+    const statuses = [];
+    const allFindings = [];
+    const offsets = {};
+    const offsetKeys = {};
+    for (const source of sources) {
+        const signatures = registry.forSource(surface.id, source.id);
+        const { status, findings } = await scanSource(source, signatures, scope, { lastLaunch });
+        if (!source.exists && missingReasons[source.id])
+            status.missingReason = missingReasons[source.id];
+        statuses.push(status);
+        allFindings.push(...findings);
+        if (status.endOffset !== undefined)
+            offsets[source.id] = status.endOffset;
+        if (status.key !== undefined)
+            offsetKeys[source.id] = status.key;
+    }
+    const truncated = allFindings.length > FINDINGS_CAP;
+    const findings = truncated ? allFindings.slice(0, FINDINGS_CAP) : allFindings;
+    const summary = { errors: 0, warnings: 0, successes: 0 };
+    for (const finding of allFindings) {
+        if (finding.category === "success")
+            summary.successes++;
+        else if (finding.severity === "error")
+            summary.errors++;
+        else if (finding.severity === "warn")
+            summary.warnings++;
+    }
+    const rootIds = new Set(sources.map((s) => s.rootId).filter((id) => id !== undefined));
+    const systems = {};
+    const systemNotes = {};
+    for (const rootId of rootIds) {
+        const rootSources = sources.filter((s) => s.rootId === rootId);
+        const rootFindings = allFindings.filter((f) => rootSources.some((s) => s.id === f.sourceId));
+        const impactfulErrors = rootFindings.filter((f) => f.severity === "error" && f.systemImpact !== false);
+        const contentFindings = rootFindings.filter((f) => f.systemImpact === false);
+        if (impactfulErrors.length > 0) {
+            systems[rootId] = "failed";
+            continue;
+        }
+        const hasSuccess = rootFindings.some((f) => f.category === "success");
+        const hasUsableSource = rootSources.some((s) => {
+            const status = statuses.find((st) => st.source.id === s.id);
+            return s.exists && status !== undefined && !status.zeroByte && !status.stale;
+        });
+        systems[rootId] = hasSuccess || hasUsableSource ? "loaded" : "unknown";
+        if (systems[rootId] === "loaded" && contentFindings.length > 0) {
+            const first = contentFindings[0];
+            const count = contentFindings.length;
+            systemNotes[rootId] =
+                `${count} content ${count === 1 ? "issue" : "issues"} found that do not affect loading ` +
+                    `(first: ${first.signatureId} at line ${first.lineNumber} — ${first.explain})`;
+        }
+    }
+    const verdict = {
+        game: surface.id,
+        install: install.root,
+        scope,
+        lastLaunch: lastLaunch?.toISOString(),
+        sources: statuses,
+        findings,
+        summary,
+        systems,
+        headline: buildHeadline(sources, statuses, allFindings, systems),
+        offsets,
+        offsetKeys,
+    };
+    if (gameRunning !== undefined)
+        verdict.gameRunning = gameRunning;
+    if (truncated)
+        verdict.truncated = true;
+    if (Object.keys(systemNotes).length > 0)
+        verdict.systemNotes = systemNotes;
+    return verdict;
+}
+function buildHeadline(sources, statuses, findings, systems) {
+    if (sources.length === 0) {
+        return "No log sources are declared for this game; triage has nothing to read.";
+    }
+    const note = [describeFullyMissingSystems(sources, statuses), describeRewrittenSources(statuses)]
+        .filter((n) => n !== undefined)
+        .join(" ") || undefined;
+    const firstError = findings.find((f) => f.severity === "error");
+    if (firstError) {
+        const source = sources.find((s) => s.id === firstError.sourceId);
+        const label = source?.label ?? firstError.sourceId;
+        return appendNote(`${label}: ${firstError.explain} (line ${firstError.lineNumber}).`, note);
+    }
+    const usableCount = statuses.filter((st) => st.source.exists && !st.zeroByte && !st.stale).length;
+    if (usableCount === 0) {
+        return appendNote(`All ${sources.length} log source(s) were stale, empty, or missing; nothing to report this run.`, note);
+    }
+    const loadedCount = Object.values(systems).filter((v) => v === "loaded").length;
+    return appendNote(`No errors in ${sources.length} sources; ${loadedCount} system(s) confirmed loaded.`, note);
+}
+function appendNote(headline, note) {
+    return note ? `${headline} ${note}` : headline;
+}
+function describeRewrittenSources(statuses) {
+    const rewritten = statuses.filter((st) => st.rewritten);
+    if (rewritten.length === 0)
+        return undefined;
+    const labels = rewritten.map((st) => st.source.label).join(", ");
+    const plural = rewritten.length > 1;
+    return (`${labels} ${plural ? "were" : "was"} truncated and rewritten in place since the last check ` +
+        `(same name, unchanged creation time); ${plural ? "their" : "its"} full content was rescanned ` +
+        `rather than treated as unchanged.`);
+}
+function describeFullyMissingSystems(sources, statuses) {
+    const notes = [];
+    const seenGroups = new Set();
+    for (const status of statuses) {
+        if (status.source.exists || !status.missingReason)
+            continue;
+        const groupKey = status.source.rootId ?? `source:${status.source.id}`;
+        if (seenGroups.has(groupKey))
+            continue;
+        const group = status.source.rootId
+            ? sources.filter((s) => s.rootId === status.source.rootId)
+            : [status.source];
+        if (!group.every((s) => !s.exists))
+            continue;
+        seenGroups.add(groupKey);
+        notes.push(`${status.source.label} is missing: ${status.missingReason}`);
+    }
+    return notes.length > 0 ? notes.join(" ") : undefined;
+}

package/dist/core/logs/types.js

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

package/dist/core/lsx.js

@@ -0,0 +1,10 @@
+export function parseMetaLsxModuleInfo(xml) {
+    const withoutComments = xml.replace(/<!--[\s\S]*?-->/g, "");
+    const node = withoutComments.match(/<node\s+id="ModuleInfo">([\s\S]*?)(?:<children>|<\/node>)/);
+    if (!node)
+        return undefined;
+    const body = node[1] ?? "";
+    const attr = (id) => body.match(new RegExp(`<attribute\\s+id="${id}"[^>]*?value="([^"]*)"`))?.[1];
+    const found = { folder: attr("Folder"), name: attr("Name"), uuid: attr("UUID"), version64: attr("Version64") };
+    return found.folder || found.name || found.uuid ? found : undefined;
+}

package/dist/core/lz4.js

@@ -0,0 +1,66 @@
+function readLengthExtra(src, pos) {
+    let extra = 0;
+    for (;;) {
+        if (pos.ip >= src.length) {
+            throw new Error("decodeLz4Block: truncated length-extension byte");
+        }
+        const b = src[pos.ip++];
+        extra += b;
+        if (b !== 255)
+            break;
+    }
+    return extra;
+}
+export function decodeLz4Block(src, expectedSize) {
+    const out = new Uint8Array(expectedSize);
+    const pos = { ip: 0 };
+    let op = 0;
+    const srcLen = src.length;
+    while (op < expectedSize) {
+        if (pos.ip >= srcLen) {
+            throw new Error(`decodeLz4Block: unexpected end of input after ${op} of ${expectedSize} output bytes`);
+        }
+        const token = src[pos.ip++];
+        let literalLength = token >> 4;
+        if (literalLength === 15)
+            literalLength += readLengthExtra(src, pos);
+        if (literalLength > 0) {
+            if (pos.ip + literalLength > srcLen) {
+                throw new Error("decodeLz4Block: literal run reads past end of input");
+            }
+            if (op + literalLength > expectedSize) {
+                throw new Error("decodeLz4Block: literal run writes past expected output size");
+            }
+            out.set(src.subarray(pos.ip, pos.ip + literalLength), op);
+            pos.ip += literalLength;
+            op += literalLength;
+        }
+        if (op >= expectedSize)
+            break;
+        if (pos.ip + 2 > srcLen) {
+            throw new Error("decodeLz4Block: truncated match offset");
+        }
+        const offset = src[pos.ip] | (src[pos.ip + 1] << 8);
+        pos.ip += 2;
+        if (offset === 0) {
+            throw new Error("decodeLz4Block: match offset of zero");
+        }
+        if (offset > op) {
+            throw new Error("decodeLz4Block: match offset points before the start of the output");
+        }
+        let matchLength = (token & 0x0f) + 4;
+        if ((token & 0x0f) === 15)
+            matchLength += readLengthExtra(src, pos);
+        if (op + matchLength > expectedSize) {
+            throw new Error("decodeLz4Block: match run writes past expected output size");
+        }
+        let from = op - offset;
+        for (let i = 0; i < matchLength; i++) {
+            out[op++] = out[from++];
+        }
+    }
+    if (op !== expectedSize) {
+        throw new Error(`decodeLz4Block: decompressed ${op} bytes, expected exactly ${expectedSize}`);
+    }
+    return out;
+}

package/dist/core/mods.js

@@ -0,0 +1,229 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { statFile, walk } from "./fsutil.js";
+import { resolveRoots } from "./surfaceutil.js";
+export async function listMods(surface, install, options = {}) {
+    const allRoots = await resolveRoots(surface, install);
+    const roots = allRoots.filter((root) => root.exists && (!options.rootIds || options.rootIds.includes(root.id)));
+    const mods = [];
+    for (const root of roots) {
+        mods.push(...(await listModsInRoot(surface, root, options.fileLimit ?? 2000)));
+    }
+    return { mods, roots: allRoots };
+}
+async function listModsInRoot(surface, root, fileLimit) {
+    const mods = [];
+    if (root.layout === "flat") {
+        const result = await walk(root.path, { limit: fileLimit });
+        if (result.files.length === 0)
+            return mods;
+        mods.push({
+            id: `${root.id}:${root.label}`,
+            name: root.label,
+            rootId: root.id,
+            path: root.path,
+            sizeBytes: result.sizeBytes,
+            modifiedAt: result.modifiedAt.toISOString(),
+            files: result.files,
+            warnings: result.truncated ? [`File listing truncated at ${fileLimit} entries.`] : undefined,
+        });
+        return mods;
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(root.path, { withFileTypes: true });
+    }
+    catch {
+        return mods;
+    }
+    for (const entry of entries) {
+        const abs = path.join(root.path, entry.name);
+        const isDir = entry.isDirectory();
+        if (root.layout === "directory" && !isDir)
+            continue;
+        if (root.layout === "file") {
+            if (isDir)
+                continue;
+            const ext = path.extname(entry.name).toLowerCase();
+            if (root.extensions && !root.extensions.includes(ext))
+                continue;
+        }
+        const result = isDir
+            ? await walk(abs, { limit: fileLimit })
+            : await statFile(abs).catch(() => undefined);
+        if (!result)
+            continue;
+        const warnings = [];
+        if (result.truncated)
+            warnings.push(`File listing truncated at ${fileLimit} entries.`);
+        let manifest;
+        if (surface.readManifest) {
+            try {
+                manifest = await surface.readManifest(abs, root);
+            }
+            catch (error) {
+                warnings.push(`Manifest unreadable: ${error.message}`);
+            }
+        }
+        mods.push({
+            id: `${root.id}:${entry.name}`,
+            name: entry.name,
+            rootId: root.id,
+            path: abs,
+            sizeBytes: result.sizeBytes,
+            modifiedAt: result.modifiedAt.toISOString(),
+            files: result.files,
+            manifest,
+            warnings: warnings.length ? warnings : undefined,
+        });
+    }
+    return mods;
+}
+const CONFLICT_NOISE = new Set([
+    "__folder_managed_by_vortex",
+    "db.sqlite3",
+    "meta.ini",
+    ".gitkeep",
+    ".keep",
+    "thumbs.db",
+    "desktop.ini",
+    ".ds_store",
+    "readme.txt",
+    "readme.md",
+    "changelog.txt",
+    "license.txt",
+]);
+function isNoise(relativePath) {
+    const base = relativePath.slice(relativePath.lastIndexOf("/") + 1).toLowerCase();
+    return CONFLICT_NOISE.has(base);
+}
+export function findConflicts(mods, roots) {
+    const byId = new Map(roots.map((root) => [root.id, root]));
+    const byRoot = new Map();
+    let suppressed = 0;
+    const skippedRoots = roots
+        .filter((root) => root.exists && root.conflictScope !== "merged")
+        .map((root) => ({
+        rootId: root.id,
+        scope: root.conflictScope,
+        reason: root.conflictScope === "isolated"
+            ? "Each mod owns a separate subtree here, so file paths cannot collide."
+            : "Mods are packed archives; conflicts inside them need game-specific unpacking.",
+    }));
+    for (const mod of mods) {
+        if (byId.get(mod.rootId)?.conflictScope !== "merged")
+            continue;
+        let claims = byRoot.get(mod.rootId);
+        if (!claims) {
+            claims = new Map();
+            byRoot.set(mod.rootId, claims);
+        }
+        for (const file of mod.files) {
+            if (isNoise(file)) {
+                suppressed++;
+                continue;
+            }
+            const key = file.toLowerCase();
+            const owners = claims.get(key);
+            if (owners)
+                owners.push(mod.id);
+            else
+                claims.set(key, [mod.id]);
+        }
+    }
+    const conflicts = [];
+    for (const [rootId, claims] of byRoot) {
+        for (const [file, owners] of claims) {
+            if (owners.length < 2)
+                continue;
+            conflicts.push({
+                path: file,
+                mods: owners,
+                rootId,
+                kind: byId.get(rootId)?.ordered ? "overwrite" : "ambiguous",
+            });
+        }
+    }
+    conflicts.sort((a, b) => b.mods.length - a.mods.length || a.path.localeCompare(b.path));
+    return { conflicts, skippedRoots, suppressedNoiseFiles: suppressed };
+}
+export const INERT_COPY_LIMIT = 25;
+export function crossCheckIdentities(order, copies, unreadable, inertLimit = INERT_COPY_LIMIT) {
+    const byUuid = new Map();
+    for (const copy of copies) {
+        if (!copy.uuid)
+            continue;
+        const key = copy.uuid.toLowerCase();
+        const list = byUuid.get(key);
+        if (list)
+            list.push(copy);
+        else
+            byUuid.set(key, [copy]);
+    }
+    const claimed = new Set();
+    const entries = order.map((entry) => {
+        const key = entry.uuid?.toLowerCase();
+        const found = key ? (byUuid.get(key) ?? []) : [];
+        if (key)
+            claimed.add(key);
+        const matches = found.map((copy) => ({
+            ...copy,
+            folderMatchesEntry: entry.folder === undefined ? undefined : copy.folder === entry.folder,
+        }));
+        return {
+            index: entry.index,
+            name: entry.name,
+            uuid: entry.uuid,
+            entryFolder: entry.folder,
+            matches,
+            duplicated: matches.length > 1,
+            missing: matches.length === 0 && !entry.baseGame,
+            ...(entry.baseGame ? { baseGame: true } : {}),
+        };
+    });
+    const inert = copies.filter((copy) => !copy.uuid || !claimed.has(copy.uuid.toLowerCase()));
+    return {
+        available: true,
+        entries,
+        inertCopies: {
+            total: inert.length,
+            ...(inert.length > inertLimit ? { truncated: true } : {}),
+            copies: inert.slice(0, inertLimit),
+        },
+        unreadable,
+    };
+}
+export const SHARED_IDENTITY_LIMIT = 25;
+export const SHARED_IDENTITY_COPY_LIMIT = 10;
+export function sharedIdentities(copies, limit = SHARED_IDENTITY_LIMIT, copyLimit = SHARED_IDENTITY_COPY_LIMIT) {
+    const byUuid = new Map();
+    for (const copy of copies) {
+        if (!copy.uuid)
+            continue;
+        const key = copy.uuid.toLowerCase();
+        const list = byUuid.get(key);
+        if (list)
+            list.push(copy);
+        else
+            byUuid.set(key, [copy]);
+    }
+    const groups = [];
+    for (const [uuid, group] of byUuid) {
+        if (group.length < 2)
+            continue;
+        groups.push([uuid, group]);
+    }
+    groups.sort((a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0]));
+    const identities = groups.slice(0, limit).map(([uuid, group]) => ({
+        uuid: group[0]?.uuid ?? uuid,
+        name: group.find((c) => c.name)?.name,
+        copyCount: group.length,
+        ...(group.length > copyLimit ? { truncated: true } : {}),
+        copies: group.slice(0, copyLimit),
+    }));
+    return {
+        total: groups.length,
+        ...(groups.length > limit ? { truncated: true } : {}),
+        identities,
+    };
+}