rea-agents 6.0.0 → 6.2.0

package/dist/native/AppleDispatchMetadata.js

@@ -77,7 +77,7 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
         evidence,
         offset,
     };
-    const { failures, examined, categoriesExamined } = decodeObjcDispatchFacets({
+    const { failures, categoryIssues, examined, categoriesExamined } = decodeObjcDispatchFacets({
         bytes,
         sections,
         segments,
@@ -91,7 +91,7 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
         budget,
         result,
     });
-    decodeSwiftDispatchFacets({
+    const swift = decodeSwiftDispatchFacets({
         sections,
         segments,
         readers,
@@ -108,7 +108,7 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
         if (section.size / 4 > maxRecords)
             budget.truncated = true;
     }
-    decodeSwiftClassVtables({
+    const vtables = decodeSwiftClassVtables({
         entries: typeEntries,
         result,
         readers: {
@@ -126,10 +126,13 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
     pushDispatchCoverage({
         result,
         failures,
+        categoryIssues,
         examined,
         categoriesExamined,
         truncated: budget.truncated,
         fixups,
+        vtables,
+        swift,
     });
     return objcSwiftMetadataSchema.parse(result);
 };

package/dist/native/AppleMachoFixups.js

@@ -1,3 +1,4 @@
+import { issue } from "./AppleDispatchDecodeFacts.js";
 const POINTER_FORMATS = {
     1: "DYLD_CHAINED_PTR_ARM64E",
     2: "DYLD_CHAINED_PTR_64",
@@ -19,39 +20,42 @@ const cString = (bytes, offset, end) => {
         throw new RangeError("Fixup symbol name is outside the symbol pool");
     return bytes.toString("utf8", offset, stop);
 };
-const readImports = (data, header) => {
+const readImport = (data, header, index) => {
     const { bytes, base, end, dylibs } = data;
     const size = header.format === 3 ? 16 : header.format === 2 ? 8 : 4;
     if (header.format < 1 || header.format > 3)
         throw new RangeError(`Unsupported chained import format ${header.format}`);
-    if (base + header.offset + header.count * size > end)
+    if (!Number.isSafeInteger(header.count) ||
+        base + header.offset + header.count * size > end)
         throw new RangeError("Chained import table exceeds the fixup data");
-    return Array.from({ length: header.count }, (_, index) => {
-        const at = base + header.offset + index * size;
-        if (header.format === 3) {
-            const word = bytes.readBigUInt64LE(at);
-            const ordinal = Number(signed(bits(word, 0, 16), 16));
-            return {
-                symbol: cString(bytes, base + header.symbols + Number(bits(word, 32, 32)), end),
-                library: libraryName(ordinal, dylibs),
-                weak: bits(word, 16, 1) === 1n,
-                addend: bytes.readBigInt64LE(at + 8),
-            };
-        }
-        const word = bytes.readUInt32LE(at);
-        const ordinal = Number(signed(BigInt(word & 0xff), 8));
+    if (index < 0 || index >= header.count)
+        throw new RangeError("Chained import index is outside the table");
+    const at = base + header.offset + index * size;
+    if (header.format === 3) {
+        const word = bytes.readBigUInt64LE(at);
+        const ordinal = Number(signed(bits(word, 0, 16), 16));
         return {
-            symbol: cString(bytes, base + header.symbols + (word >>> 9), end),
+            symbol: cString(bytes, base + header.symbols + Number(bits(word, 32, 32)), end),
             library: libraryName(ordinal, dylibs),
-            weak: ((word >>> 8) & 1) === 1,
-            addend: header.format === 2 ? BigInt(bytes.readInt32LE(at + 4)) : 0n,
+            weak: bits(word, 16, 1) === 1n,
+            addend: bytes.readBigInt64LE(at + 8),
         };
-    });
+    }
+    const word = bytes.readUInt32LE(at);
+    const ordinal = Number(signed(BigInt(word & 0xff), 8));
+    return {
+        symbol: cString(bytes, base + header.symbols + (word >>> 9), end),
+        library: libraryName(ordinal, dylibs),
+        weak: ((word >>> 8) & 1) === 1,
+        addend: header.format === 2 ? BigInt(bytes.readInt32LE(at + 4)) : 0n,
+    };
 };
 /** Decode one raw chained pointer for its segment's pointer format. */
 export const decodeChainedPointer = (raw, format, baseAddress, imports) => {
     const bind = (ordinal, addend) => {
-        const target = imports[Number(ordinal)];
+        const target = typeof imports === "function"
+            ? imports(Number(ordinal))
+            : imports[Number(ordinal)];
         if (target === undefined)
             throw new RangeError(`Chained bind ordinal ${ordinal} has no import`);
         return { kind: "bind", ...target, addend: target.addend + addend };
@@ -86,12 +90,19 @@ const chainedFixups = (image, range) => {
     if (range.size < 28 || end > bytes.length)
         throw new RangeError("Chained fixup header exceeds the target");
     const startsOffset = bytes.readUInt32LE(base + 4);
-    const imports = readImports({ bytes, base, end, dylibs }, {
+    const importHeader = {
         offset: bytes.readUInt32LE(base + 8),
         symbols: bytes.readUInt32LE(base + 12),
         count: bytes.readUInt32LE(base + 16),
         format: bytes.readUInt32LE(base + 20),
-    });
+    };
+    const importSize = importHeader.format === 3 ? 16 : importHeader.format === 2 ? 8 : 4;
+    const importTableEnd = base + importHeader.offset + importHeader.count * importSize;
+    if (importHeader.format < 1 || importHeader.format > 3)
+        throw new RangeError(`Unsupported chained import format ${importHeader.format}`);
+    if (!Number.isSafeInteger(importHeader.count) || importTableEnd > end)
+        throw new RangeError("Chained import table exceeds the fixup data");
+    const imports = (index) => readImport({ bytes, base, end, dylibs }, importHeader, index);
     if (bytes.readUInt32LE(base + 24) !== 0)
         throw new RangeError("Compressed chained-fixup symbol names are not supported");
     const starts = base + startsOffset;
@@ -113,10 +124,16 @@ const chainedFixups = (image, range) => {
     const formats = [
         ...new Set(ranges.map(({ format }) => POINTER_FORMATS[format] ?? `format-${format}`)),
     ];
+    const issues = ranges.flatMap(({ format, from }) => POINTER_FORMATS[format] === undefined
+        ? [
+            issue("pointer_fixups", "unsupported_pointer_format", `Unsupported chained pointer format ${format}`, `0x${from.toString(16)}`),
+        ]
+        : []);
     return {
         kind: "chained",
         formats,
-        failures: [],
+        failures: issues.map(({ message }) => message),
+        issues,
         decode(address, raw) {
             const segment = ranges.find(({ from, to }) => address >= from && address < to);
             // Pointers outside fixup segments, such as in __TEXT, are stored plainly.
@@ -124,6 +141,11 @@ const chainedFixups = (image, range) => {
                 return { kind: "rebase", target: raw };
             if (raw === 0n)
                 return { kind: "rebase", target: 0n };
+            if (POINTER_FORMATS[segment.format] === undefined)
+                return {
+                    kind: "unsupported",
+                    reason: `Unsupported chained pointer format ${segment.format}`,
+                };
             return decodeChainedPointer(raw, segment.format, baseAddress, imports);
         },
     };
@@ -267,6 +289,7 @@ export const parsePointerFixups = (bytes, commands, segments, baseAddress) => {
             kind: "none",
             formats: [],
             failures: [],
+            issues: [],
             decode: (_address, raw) => ({ kind: "rebase", target: raw }),
         };
     const binds = new Map();
@@ -282,6 +305,7 @@ export const parsePointerFixups = (bytes, commands, segments, baseAddress) => {
         kind: "dyld-info",
         formats: [],
         failures,
+        issues: failures.map((message) => issue("pointer_fixups", "bind_stream_decode_failed", message)),
         decode(address, raw) {
             const bound = binds.get(address);
             return bound === undefined

package/dist/native/AppleMachoSelection.js

@@ -1,3 +1,4 @@
+import { readFatSliceDeclarations, validateFatSlice, } from "../domain/apple/machoContainer.js";
 const hex = (value) => `0x${value.toString(16)}`;
 /** Classify a FAT magic word; thin Mach-O returns null. */
 export const fatHeaderFormat = (magic) => {
@@ -25,9 +26,6 @@ export const selectMachoSlice = (bytes, architecture) => {
     const readUInt32 = littleEndian
         ? (offset) => bytes.readUInt32LE(offset)
         : (offset) => bytes.readUInt32BE(offset);
-    const readUInt64 = littleEndian
-        ? (offset) => bytes.readBigUInt64LE(offset)
-        : (offset) => bytes.readBigUInt64BE(offset);
     const byteOrder = littleEndian ? "little-endian" : "big-endian";
     const malformed = (reason) => new RangeError(`${reason} (FAT header byte order: ${byteOrder})`);
     const invalid = (reason) => new TypeError(`${reason} (FAT header byte order: ${byteOrder})`);
@@ -38,22 +36,30 @@ export const selectMachoSlice = (bytes, architecture) => {
     if (count > 128 || headerEnd > bytes.length)
         throw malformed("Malformed FAT architecture table");
     const cpu = architecture === "arm64" ? 0x0100000c : 0x01000007;
+    const declarations = readFatSliceDeclarations(bytes.subarray(8, headerEnd), {
+        count,
+        wide: fat64,
+        littleEndian,
+    });
+    if (declarations.status !== "parsed")
+        throw malformed(declarations.reason);
     let selected;
-    for (let index = 0; index < count; index++) {
-        const offset = 8 + index * stride;
-        if (readUInt32(offset) !== cpu)
+    for (const declaration of declarations.slices) {
+        const issue = validateFatSlice(declaration, bytes.length, headerEnd);
+        if (issue !== null)
+            throw malformed(issue);
+        if (declaration.cpuType !== cpu)
             continue;
         if (selected !== undefined)
             throw invalid("Ambiguous FAT architecture slice");
-        const start = fat64
-            ? readUInt64(offset + 8)
-            : BigInt(readUInt32(offset + 8));
-        const size = fat64
-            ? readUInt64(offset + 16)
-            : BigInt(readUInt32(offset + 12));
-        if (start < BigInt(headerEnd) || start + size > BigInt(bytes.length))
-            throw malformed("FAT slice exceeds file");
-        selected = { slice: Number(start), sliceEnd: Number(start + size) };
+        selected = {
+            slice: declaration.offset,
+            sliceEnd: declaration.offset + declaration.size,
+            fatDeclaration: {
+                ...declaration,
+                tableEnd: headerEnd,
+            },
+        };
     }
     if (selected === undefined)
         throw invalid("Requested FAT architecture is absent");
@@ -63,11 +69,21 @@ export const selectMachoSlice = (bytes, architecture) => {
 export const parseMachoLayout = (bytes, architecture) => {
     if (bytes.length < 4)
         throw new RangeError("Truncated Mach-O header");
-    const { slice, sliceEnd } = selectMachoSlice(bytes, architecture);
+    const selection = selectMachoSlice(bytes, architecture);
+    const { slice, sliceEnd } = selection;
     if (slice === 0 && sliceEnd === bytes.length && bytes.length < 32)
         throw new RangeError("Truncated Mach-O header");
     if (slice + 32 > sliceEnd || bytes.readUInt32LE(slice) !== 0xfeedfacf)
         throw new TypeError("Only little-endian 64-bit Mach-O metadata is supported");
+    const fat = selection.fatDeclaration;
+    if (fat !== undefined) {
+        const issue = validateFatSlice(fat, bytes.length, fat.tableEnd, {
+            cpuType: bytes.readUInt32LE(slice + 4),
+            cpuSubtype: bytes.readUInt32LE(slice + 8),
+        });
+        if (issue !== null)
+            throw new TypeError(issue);
+    }
     const commands = bytes.readUInt32LE(slice + 16);
     const commandEnd = slice + 32 + bytes.readUInt32LE(slice + 20);
     if (commands > 4096 || commandEnd > sliceEnd)
@@ -166,9 +182,14 @@ const collectFixupCommand = (bytes, { cursor, kind, size }, state) => {
             throw new RangeError("Fixup data exceeds the Mach-O slice");
         return { offset, size: length };
     };
-    if (kind === LC_DYLD_CHAINED_FIXUPS && size >= 16)
+    if (kind === LC_DYLD_CHAINED_FIXUPS) {
+        if (size < 16)
+            throw new RangeError("Truncated chained-fixups command");
         state.chained = range(cursor + 8);
-    else if ((kind === LC_DYLD_INFO || kind === LC_DYLD_INFO_ONLY) && size >= 48)
+    }
+    else if (kind === LC_DYLD_INFO || kind === LC_DYLD_INFO_ONLY) {
+        if (size < 48)
+            throw new RangeError("Truncated dyld-info command");
         for (const [at, stream] of [
             [cursor + 16, "bind"],
             [cursor + 24, "weak"],
@@ -178,11 +199,16 @@ const collectFixupCommand = (bytes, { cursor, kind, size }, state) => {
             if (bound.size > 0)
                 state.binds.push({ ...bound, stream });
         }
-    else if (DYLIB_COMMANDS.includes(kind) && size >= 24) {
+    }
+    else if (DYLIB_COMMANDS.includes(kind)) {
+        if (size < 24)
+            throw new RangeError("Truncated dylib command");
         const nameOffset = bytes.readUInt32LE(cursor + 8);
+        if (nameOffset < 24 || nameOffset >= size)
+            throw new RangeError("Dylib install name is outside its load command");
         const end = bytes.indexOf(0, cursor + nameOffset);
-        state.dylibs.push(nameOffset >= size || end < 0 || end > cursor + size
-            ? ""
-            : bytes.toString("utf8", cursor + nameOffset, end));
+        if (end < 0 || end >= cursor + size)
+            throw new RangeError("Unterminated dylib install name");
+        state.dylibs.push(bytes.toString("utf8", cursor + nameOffset, end));
     }
 };

package/dist/native/AppleObjcCategories.js

@@ -1,4 +1,5 @@
 import { readObjcPropertiesOf } from "./AppleObjcProperties.js";
+import { issue } from "./AppleDispatchDecodeFacts.js";
 const CLASS_SYMBOL = /^_OBJC_(?:META)?CLASS_\$_(.+)$/u;
 /** External class name from a bound `_OBJC_CLASS_$_Name` symbol. */
 export const boundClassName = (read, field) => {
@@ -41,7 +42,8 @@ export const decodeObjcCategories = (input) => {
                     properties: readObjcPropertiesOf(read, read.pointer(category + 40n), {
                         owner: `category ${name}`,
                         admit: input.admit,
-                        failures,
+                        issues: input.issues,
+                        location: `0x${read.pointer(category + 40n).toString(16)}`,
                     }),
                     location: read.location(category),
                     decode: className === null
@@ -51,7 +53,9 @@ export const decodeObjcCategories = (input) => {
                 });
             }
             catch (cause) {
-                failures.push(`Category at ${`0x${field.toString(16)}`}: ${cause instanceof Error ? cause.message : String(cause)}`);
+                const message = cause instanceof Error ? cause.message : String(cause);
+                failures.push(`Category at 0x${field.toString(16)}: ${message}`);
+                input.issues.push(issue("objc_properties_categories", "category_decode_failed", message, `0x${field.toString(16)}`));
             }
         }
     }

package/dist/native/AppleObjcDispatchFacets.js

@@ -30,6 +30,7 @@ const resolveSuperclass = (read, address, className, failures) => {
 export const decodeObjcDispatchFacets = (input) => {
     const { bytes, sections, segments, readers: read, budget, result } = input;
     const failures = [];
+    const categoryIssues = [];
     let examined = 0;
     const methods = (list, className, methodType, category) => {
         const selectors = [];
@@ -203,7 +204,8 @@ export const decodeObjcDispatchFacets = (input) => {
             properties: readObjcPropertiesOf(read, read.pointer(ro + 64n), {
                 owner: name,
                 admit: () => budget.admit(),
-                failures,
+                issues: categoryIssues,
+                location: hex(read.pointer(ro + 64n)),
             }),
             protocols: protocolReader.list(read.pointer(ro + 40n)),
             ivar_count: ivarCount,
@@ -248,10 +250,11 @@ export const decodeObjcDispatchFacets = (input) => {
         read,
         result,
         failures,
+        issues: categoryIssues,
         admit: () => budget.admit(),
         methods,
         protocols: (list) => protocolReader.list(list),
         localClassName: (address) => localClassName(read, address),
     });
-    return { failures, examined, categoriesExamined };
+    return { failures, categoryIssues, examined, categoriesExamined };
 };

package/dist/native/AppleObjcProperties.js

@@ -1,3 +1,4 @@
+import { issue } from "./AppleDispatchDecodeFacts.js";
 /**
  * Parse an `@property` attribute string such as `T@"NSString",C,N,V_name`.
  * Each comma-separated token is one attribute; `T` is the type encoding.
@@ -62,7 +63,7 @@ export const readObjcPropertiesOf = (read, list, context) => {
         return readObjcPropertyList(read, list, context.admit);
     }
     catch (cause) {
-        context.failures.push(`Properties of ${context.owner}: ${cause instanceof Error ? cause.message : String(cause)}`);
+        context.issues.push(issue("objc_properties_categories", "property_decode_failed", `${context.owner}: ${cause instanceof Error ? cause.message : String(cause)}`, context.location));
         return [];
     }
 };

package/dist/native/AppleSwiftDispatchFacets.js

@@ -1,3 +1,4 @@
+import { issue } from "./AppleDispatchDecodeFacts.js";
 const hex = (value) => `0x${value.toString(16)}`;
 const decoded = { status: "decoded", reason: null };
 /** Create a Swift ABI signed-relative pointer decoder that records relative_pointers. */
@@ -42,7 +43,9 @@ export const createSwiftRelativeReader = (input) => {
 export const decodeSwiftDispatchFacets = (input) => {
     const { sections, segments, readers: read, relative, budget, result } = input;
     const swiftFailures = [];
+    const issues = [];
     let swiftExamined = 0;
+    let decodedRecords = 0;
     for (const section of sections.filter(({ name }) => name === "__swift5_proto")) {
         if (section.size % 4 !== 0)
             throw new RangeError("Misaligned Swift conformance section");
@@ -77,6 +80,9 @@ export const decodeSwiftDispatchFacets = (input) => {
                 if (staticWitness && read.pointer(witness) !== descriptor)
                     witnessReason =
                         "Witness-table conformance header is unresolved or encoded";
+                const conformanceDecode = witnessReason === null
+                    ? { status: "decoded", reason: null }
+                    : { status: "partial", reason: witnessReason };
                 result.swift_conformances.push({
                     type_name: typeName,
                     protocol_name: protocolName,
@@ -85,16 +91,14 @@ export const decodeSwiftDispatchFacets = (input) => {
                         ? { address: null, file_offset: null }
                         : read.location(witness),
                     location: read.location(descriptor),
-                    decode: witnessReason === null
-                        ? decoded
-                        : {
-                            status: "partial",
-                            reason: witnessReason,
-                        },
+                    decode: conformanceDecode,
                     evidence: read.evidence(descriptor, "Swift protocol conformance descriptor and directly encoded type/protocol names"),
                 });
+                if (conformanceDecode.status === "decoded")
+                    decodedRecords++;
                 if (witnessReason !== null) {
                     swiftFailures.push(`${typeName}: ${witnessReason}`);
+                    issues.push(issue("swift_conformances_static_witness_slots", "conformance_decode_partial", witnessReason, hex(descriptor)));
                     continue;
                 }
                 const count = read.u32(protocol + 16n);
@@ -113,6 +117,12 @@ export const decodeSwiftDispatchFacets = (input) => {
                         segments.some((segment) => segment.executable &&
                             implementation >= segment.address &&
                             implementation < segment.address + segment.size);
+                    const slotDecode = executable
+                        ? { status: "decoded", reason: null }
+                        : {
+                            status: "partial",
+                            reason: "Witness slot is non-function, async, nil, external, authenticated or encoded; implementation target is unresolved",
+                        };
                     result.swift_dispatch_slots.push({
                         owner: `${typeName}: ${protocolName}`,
                         table_kind: "witness_table",
@@ -122,29 +132,25 @@ export const decodeSwiftDispatchFacets = (input) => {
                         implementation_address: executable ? hex(implementation) : null,
                         thunk_address: null,
                         location: read.location(entry),
-                        decode: executable
-                            ? decoded
-                            : {
-                                status: "partial",
-                                reason: "Witness slot is non-function, async, nil, external, authenticated or encoded; implementation target is unresolved",
-                            },
+                        decode: slotDecode,
                         evidence: read.evidence(entry, "Static Swift witness slot, indexed after the conformance-descriptor header"),
                     });
+                    if (slotDecode.status !== "decoded")
+                        issues.push(issue("swift_conformances_static_witness_slots", "witness_slot_unresolved", slotDecode.reason, hex(entry)));
                 }
             }
             catch (cause) {
-                swiftFailures.push(`${hex(field)}: ${cause instanceof Error ? cause.message : String(cause)}`);
+                const message = cause instanceof Error ? cause.message : String(cause);
+                swiftFailures.push(`${hex(field)}: ${message}`);
+                issues.push(issue("swift_conformances_static_witness_slots", "conformance_decode_failed", message, hex(field)));
             }
         }
     }
-    result.coverage.push({
+    return {
         facet: "swift_conformances_static_witness_slots",
-        status: swiftFailures.length > 0 || budget.truncated ? "partial" : "complete",
-        reason: [
-            ...swiftFailures,
-            ...(budget.truncated ? ["max_records_reached"] : []),
-        ].join("; ") || null,
         examined: swiftExamined,
-        decoded: result.swift_conformances.length,
-    });
+        decoded: decodedRecords,
+        exhaustive: !budget.truncated && issues.length === 0,
+        issues,
+    };
 };

package/dist/native/AppleSwiftVtables.js

@@ -1,11 +1,15 @@
+import { issue } from "./AppleDispatchDecodeFacts.js";
 /** Decode non-generic, non-resilient Swift class vtable descriptors without instantiating metadata. */
 export const decodeSwiftClassVtables = (input) => {
     const { readers: read, result } = input;
     const failures = [];
+    const issues = [];
     let examined = 0;
+    let decoded = 0;
     for (const field of input.entries) {
         if (!read.admit()) {
             failures.push("max_records_reached");
+            issues.push(issue("swift_class_vtable_descriptors", "record_budget_exhausted", "max_records_reached", `0x${field.toString(16)}`));
             break;
         }
         examined++;
@@ -32,11 +36,12 @@ export const decodeSwiftClassVtables = (input) => {
                 throw new RangeError("Swift vtable count or offset exceeds declared metadata bounds");
             const owner = read.string(read.relative(descriptor + 8n));
             for (let index = 0; index < count; index++) {
+                const entry = header + 8n + BigInt(index * 8);
                 if (!read.admit()) {
                     failures.push("max_records_reached");
+                    issues.push(issue("swift_class_vtable_descriptors", "record_budget_exhausted", "max_records_reached", `0x${entry.toString(16)}`));
                     break;
                 }
-                const entry = header + 8n + BigInt(index * 8);
                 const methodFlags = read.u32(entry);
                 // Async slots reference async descriptors; coroutine and future kinds need separate decoders.
                 const synchronous = (methodFlags & 0x40) === 0 && (methodFlags & 15) <= 3;
@@ -61,26 +66,27 @@ export const decodeSwiftClassVtables = (input) => {
                         },
                     evidence: read.evidence(entry, "Swift class vtable method descriptor; slot index is a metadata word offset, not a source method ordinal"),
                 });
+                if (resolved)
+                    decoded++;
+                else
+                    issues.push(issue("swift_class_vtable_descriptors", "vtable_implementation_unresolved", "Async, coroutine, external or unmapped vtable implementation is unresolved", `0x${entry.toString(16)}`));
             }
-            if ((specific & 0x4000) !== 0)
+            if ((specific & 0x4000) !== 0) {
                 failures.push(`${owner}: inherited override descriptors are unsupported`);
+                issues.push(issue("swift_class_vtable_descriptors", "inherited_override_descriptors_unsupported", "Inherited override descriptors are unsupported", `0x${descriptor.toString(16)}`));
+            }
         }
         catch (cause) {
-            failures.push(`0x${field.toString(16)}: ${cause instanceof Error ? cause.message : String(cause)}`);
+            const message = cause instanceof Error ? cause.message : String(cause);
+            failures.push(`0x${field.toString(16)}: ${message}`);
+            issues.push(issue("swift_class_vtable_descriptors", "vtable_decode_failed", message, `0x${field.toString(16)}`));
         }
     }
-    const slots = result.swift_dispatch_slots.filter((slot) => slot.table_kind === "class_vtable");
-    result.coverage.push({
+    return {
         facet: "swift_class_vtable_descriptors",
         examined,
-        decoded: slots.filter((slot) => slot.decode.status === "decoded").length,
-        status: failures.length > 0 ||
-            slots.some((slot) => slot.decode.status !== "decoded")
-            ? "partial"
-            : "complete",
-        reason: failures.join("; ") ||
-            (slots.some((slot) => slot.decode.status !== "decoded")
-                ? "vtable_implementations_unresolved"
-                : null),
-    });
+        decoded,
+        exhaustive: issues.length === 0,
+        issues,
+    };
 };