reverseport 0.0.0-stage → 1.2.0

package/dist/native/AppleObjcDispatchFacets.js

@@ -0,0 +1,260 @@
+import { boundClassName, decodeObjcCategories } from "./AppleObjcCategories.js";
+import { readObjcPropertiesOf } from "./AppleObjcProperties.js";
+import { createObjcProtocolReader } from "./AppleObjcProtocols.js";
+const hex = (value) => `0x${value.toString(16)}`;
+const decoded = { status: "decoded", reason: null };
+/** Name of a class defined in this image, from its class_ro_t. */
+const localClassName = (read, address) => read.string(read.pointer((read.pointer(address + 32n) & ~7n) + 24n));
+/**
+ * Resolve a class's superclass: a bind to `_OBJC_CLASS_$_Name` names a class
+ * in another image; otherwise the pointer is a class_t in this image.
+ */
+const resolveSuperclass = (read, address, className, failures) => {
+    const external = boundClassName(read, address + 8n);
+    if (external !== undefined)
+        return { name: external, address: null };
+    const superclass = read.pointer(address + 8n);
+    if (superclass === 0n)
+        return { name: null, address: null };
+    try {
+        return { name: localClassName(read, superclass), address: hex(superclass) };
+    }
+    catch (cause) {
+        // Superclass resolution failure is recorded; the cause adds no identity.
+        void cause;
+        failures.push(`Superclass pointer ${hex(superclass)} of ${className} requires unsupported binding/fixup resolution`);
+        return { name: null, address: hex(superclass) };
+    }
+};
+/** Decode Objective-C protocol lists, classlists, methods, and ivars into `result`. */
+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 = [];
+        if (list === 0n)
+            return selectors;
+        const flags = read.u32(list), count = read.u32(list + 4n), relative = (flags & 0x80000000) !== 0;
+        const stride = flags & 0xfffc;
+        if (stride !== (relative ? 12 : 24))
+            throw new TypeError(`Unsupported method stride/flags at ${hex(list)}`);
+        for (let index = 0; index < count; index++) {
+            if (!budget.admit())
+                break;
+            const entry = list + 8n + BigInt(index * stride);
+            const rel = (field) => {
+                const displacement = bytes.readInt32LE(read.offset(field, 4));
+                const target = field + BigInt(displacement);
+                let fileOffset = null;
+                try {
+                    fileOffset = read.offset(target);
+                }
+                catch (cause) {
+                    // best-effort cleanup: serialized target remains unresolved.
+                    void cause;
+                }
+                if (budget.admit())
+                    result.relative_pointers.push({
+                        field: read.location(field),
+                        target: { address: hex(target), file_offset: fileOffset },
+                        displacement,
+                        indirectable: false,
+                        indirect: false,
+                        decode: fileOffset === null
+                            ? { status: "partial", reason: "relative_target_unmapped" }
+                            : decoded,
+                        evidence: read.evidence(field, "Signed-relative Objective-C method-list pointer"),
+                    });
+                return target;
+            };
+            let selectorAddress = relative ? rel(entry) : read.pointer(entry);
+            if (relative && (flags & 0x40000000) === 0)
+                selectorAddress = read.pointer(selectorAddress);
+            const implementation = relative
+                ? rel(entry + 8n)
+                : read.pointer(entry + 16n);
+            let implementationLocation = null;
+            try {
+                if (!segments.some((segment) => segment.executable &&
+                    implementation >= segment.address &&
+                    implementation < segment.address + segment.size))
+                    throw new RangeError("Method implementation is not in an executable segment");
+                implementationLocation = read.location(implementation);
+            }
+            catch (cause) {
+                // best-effort cleanup: external/chained pointers remain unresolved.
+                void cause;
+            }
+            const selector = read.string(selectorAddress);
+            selectors.push(selector);
+            result.objc_dispatch_implementations.push({
+                class_name: className,
+                selector,
+                method_type: methodType,
+                ...(category === undefined ? {} : { category }),
+                implementation_address: implementationLocation?.address ?? null,
+                location: read.location(entry),
+                decode: implementationLocation === null
+                    ? {
+                        status: "partial",
+                        reason: "implementation_pointer_unmapped_or_encoded",
+                    }
+                    : decoded,
+                evidence: read.evidence(entry, relative
+                    ? "Encoded relative Objective-C method entry"
+                    : "Encoded absolute Objective-C method entry"),
+            });
+        }
+        return selectors;
+    };
+    const protocolReader = createObjcProtocolReader({
+        readers: {
+            u32: read.u32,
+            pointer: read.pointer,
+            string: read.string,
+            location: read.location,
+            evidence: read.evidence,
+            admit: () => budget.admit(),
+            i32: read.i32,
+            u64: read.u64,
+        },
+        result,
+        failures,
+    });
+    for (const section of sections.filter(({ name }) => name === "__objc_protolist")) {
+        if (section.size % 8 !== 0)
+            throw new RangeError("Misaligned Objective-C protocol list");
+        for (let index = 0; index < section.size / 8; index++) {
+            if (budget.isFull()) {
+                budget.markTruncated();
+                break;
+            }
+            protocolReader.record(read.pointer(section.address + BigInt(index * 8)));
+        }
+    }
+    const visited = new Set();
+    const readClass = (address, meta = false) => {
+        if (address === 0n || visited.has(hex(address)) || !budget.admit())
+            return;
+        visited.add(hex(address));
+        const ro = read.pointer(address + 32n) & ~7n;
+        const name = read.string(read.pointer(ro + 24n));
+        const root = (read.u32(ro) & 2) !== 0;
+        const superclass = resolveSuperclass(read, address, name, failures);
+        if (superclass.name === null && superclass.address === null && !root)
+            failures.push(`Superclass of ${name} requires external binding resolution`);
+        const ivarList = read.pointer(ro + 48n);
+        let ivarCount = meta ? null : 0;
+        if (ivarList !== 0n && !meta) {
+            const stride = read.u32(ivarList), count = read.u32(ivarList + 4n);
+            if (stride !== 32)
+                throw new TypeError("Unsupported Objective-C ivar entry size");
+            ivarCount = count;
+            for (let index = 0; index < count; index++) {
+                if (!budget.admit())
+                    break;
+                const entry = ivarList + 8n + BigInt(index * stride);
+                const encodedOffset = read.pointer(entry);
+                let value = null;
+                try {
+                    value = read.u32(encodedOffset);
+                }
+                catch (cause) {
+                    // Unresolved offsets are recorded; the cause adds no identity.
+                    void cause;
+                    failures.push(`Unresolved ivar offset pointer ${hex(encodedOffset)}`);
+                }
+                result.objc_ivars.push({
+                    class_name: name,
+                    name: read.string(read.pointer(entry + 8n)),
+                    type_encoding: read.string(read.pointer(entry + 16n)),
+                    offset: value,
+                    size: read.u32(entry + 28n),
+                    alignment: read.u32(entry + 24n) < 31 ? 2 ** read.u32(entry + 24n) : null,
+                    location: read.location(entry),
+                    decode: value === null
+                        ? { status: "partial", reason: "ivar_offset_pointer_unresolved" }
+                        : decoded,
+                    evidence: read.evidence(entry, "Objective-C ivar entry and encoded offset storage"),
+                });
+            }
+        }
+        methods(read.pointer(ro + 32n), name, meta ? "class" : "instance");
+        result.objc_classes.push({
+            name,
+            super_class: superclass.name,
+            is_meta_class: meta,
+            is_root_class: root,
+            methods: result.objc_dispatch_implementations
+                .filter((item) => item.class_name === name &&
+                item.method_type === (meta ? "class" : "instance"))
+                .map((item) => ({
+                selector: item.selector,
+                method_type: item.method_type,
+                address: item.implementation_address !== null &&
+                    BigInt(item.implementation_address) <=
+                        BigInt(Number.MAX_SAFE_INTEGER)
+                    ? Number(BigInt(item.implementation_address))
+                    : null,
+                is_required: null,
+                is_optional: null,
+            })),
+            properties: readObjcPropertiesOf(read, read.pointer(ro + 64n), {
+                owner: name,
+                admit: () => budget.admit(),
+                issues: categoryIssues,
+                location: hex(read.pointer(ro + 64n)),
+            }),
+            protocols: protocolReader.list(read.pointer(ro + 40n)),
+            ivar_count: ivarCount,
+            instance_size: read.u32(ro + 8n),
+            location: read.location(address),
+            superclass_address: superclass.address,
+            metaclass_address: meta ? null : hex(read.pointer(address)),
+            decode: superclass.name === null && !root
+                ? { status: "partial", reason: "superclass_binding_unresolved" }
+                : decoded,
+            evidence: read.evidence(address, "Objective-C class and class_ro_t records"),
+        });
+        if (!meta) {
+            try {
+                readClass(read.pointer(address), true);
+            }
+            catch (cause) {
+                failures.push(`Metaclass of ${name}: ${cause instanceof Error ? cause.message : String(cause)}`);
+            }
+        }
+    };
+    for (const section of sections.filter(({ name }) => name === "__objc_classlist")) {
+        if (section.size % 8 !== 0)
+            throw new RangeError("Misaligned Objective-C class-list size");
+        for (let index = 0; index < section.size / 8; index++) {
+            if (budget.isFull()) {
+                budget.markTruncated();
+                break;
+            }
+            examined++;
+            const field = section.address + BigInt(index * 8);
+            try {
+                readClass(read.pointer(field));
+            }
+            catch (cause) {
+                failures.push(`${hex(field)}: ${cause instanceof Error ? cause.message : String(cause)}`);
+            }
+        }
+    }
+    const categoriesExamined = decodeObjcCategories({
+        sections,
+        read,
+        result,
+        failures,
+        issues: categoryIssues,
+        admit: () => budget.admit(),
+        methods,
+        protocols: (list) => protocolReader.list(list),
+        localClassName: (address) => localClassName(read, address),
+    });
+    return { failures, categoryIssues, examined, categoriesExamined };
+};

package/dist/native/AppleObjcProperties.js

@@ -0,0 +1,79 @@
+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.
+ */
+export const parsePropertyAttributes = (name, attributes) => {
+    const tokens = attributes.length === 0 ? [] : splitAttributes(attributes);
+    const typeAttributes = tokens.filter((token) => token[0] === "T");
+    const typeAttribute = typeAttributes.length === 1 ? typeAttributes[0] : undefined;
+    const typeEncoding = typeAttribute !== undefined && typeAttribute.length > 1
+        ? typeAttribute.slice(1)
+        : null;
+    const value = (code) => tokens.find((token) => token[0] === code)?.slice(1) ?? null;
+    return {
+        name,
+        type_encoding: typeEncoding,
+        attributes: tokens.map((token) => ({
+            name: token.slice(0, 1),
+            value: token.slice(1),
+        })),
+        atomicity: tokens.includes("N")
+            ? "nonatomic"
+            : typeEncoding === null
+                ? null
+                : "atomic",
+        is_readonly: tokens.includes("R")
+            ? true
+            : typeEncoding === null
+                ? null
+                : false,
+        getter: value("G"),
+        setter: value("S"),
+    };
+};
+/** Split on commas that are outside a quoted class name in the type encoding. */
+const splitAttributes = (attributes) => {
+    const tokens = [];
+    let current = "";
+    let quoted = false;
+    for (const character of attributes) {
+        if (character === '"')
+            quoted = !quoted;
+        if (character === "," && !quoted) {
+            tokens.push(current);
+            current = "";
+        }
+        else
+            current += character;
+    }
+    tokens.push(current);
+    return tokens.filter((token) => token.length > 0);
+};
+/** Decode `property_list_t { entsize_and_flags, count, property_t[] }`. */
+export const readObjcPropertyList = (read, list, admit) => {
+    if (list === 0n)
+        return [];
+    const entrySize = read.u32(list) & ~3;
+    const count = read.u32(list + 4n);
+    if (entrySize !== 16)
+        throw new TypeError(`Unsupported Objective-C property entry size ${entrySize}`);
+    const properties = [];
+    for (let index = 0; index < count; index++) {
+        if (!admit())
+            break;
+        const entry = list + 8n + BigInt(index * entrySize);
+        properties.push(parsePropertyAttributes(read.string(read.pointer(entry)), read.string(read.pointer(entry + 8n))));
+    }
+    return properties;
+};
+/** Decode a property list, recording a failure for `owner` instead of throwing. */
+export const readObjcPropertiesOf = (read, list, context) => {
+    try {
+        return readObjcPropertyList(read, list, context.admit);
+    }
+    catch (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/AppleObjcProtocols.js

@@ -0,0 +1,89 @@
+/** Read protocol lists and absolute protocol method declarations with cycle-safe identities. */
+export const createObjcProtocolReader = (input) => {
+    const { readers: read, result, failures } = input;
+    const visited = new Set();
+    const name = (address) => read.string(read.pointer(address + 8n));
+    const list = (address) => {
+        if (address === 0n)
+            return [];
+        // `count` is plain uintptr_t data, not a pointer fixup.
+        const count = read.u64(address);
+        if (count > 20000n)
+            throw new RangeError("Protocol list exceeds 20000 entries");
+        const names = [];
+        for (let index = 0n; index < count; index++) {
+            if (!read.admit())
+                break;
+            const protocol = read.pointer(address + 8n + index * 8n);
+            names.push(name(protocol));
+            record(protocol);
+        }
+        return names;
+    };
+    const methods = (address, required, instance) => {
+        const output = [];
+        if (address === 0n)
+            return output;
+        const flags = read.u32(address), count = read.u32(address + 4n);
+        const relative = (flags & 0x80000000) !== 0;
+        const stride = flags & 0xfffc;
+        if (stride !== (relative ? 12 : 24))
+            throw new TypeError("Unsupported Objective-C protocol method entry size");
+        for (let index = 0; index < count; index++) {
+            if (!read.admit())
+                break;
+            const entry = address + 8n + BigInt(index * stride);
+            let selector = relative
+                ? entry + BigInt(read.i32(entry))
+                : read.pointer(entry);
+            if (relative && (flags & 0x40000000) === 0)
+                selector = read.pointer(selector);
+            output.push({
+                selector: read.string(selector),
+                method_type: instance ? "instance" : "class",
+                address: null,
+                is_required: required,
+                is_optional: !required,
+            });
+        }
+        return output;
+    };
+    const record = (address) => {
+        if (address === 0n || visited.has(address) || !read.admit())
+            return;
+        visited.add(address);
+        try {
+            if (read.u32(address + 64n) < 72)
+                throw new RangeError("Truncated Objective-C protocol declaration");
+            const protocolName = name(address);
+            const adopted = list(read.pointer(address + 16n));
+            const required = [
+                ...methods(read.pointer(address + 24n), true, true),
+                ...methods(read.pointer(address + 32n), true, false),
+            ];
+            const optional = [
+                ...methods(read.pointer(address + 40n), false, true),
+                ...methods(read.pointer(address + 48n), false, false),
+            ];
+            result.objc_protocols.push({
+                name: protocolName,
+                methods: required,
+                optional_methods: optional,
+                properties: [],
+            });
+            result.objc_protocol_records.push({
+                name: protocolName,
+                adopted_protocols: adopted,
+                methods: required,
+                optional_methods: optional,
+                location: read.location(address),
+                decode: { status: "decoded", reason: null },
+                evidence: read.evidence(address, "Objective-C protocol declaration and encoded method lists; IMP fields are not handler targets"),
+            });
+        }
+        catch (cause) {
+            failures.push(`Protocol 0x${address.toString(16)}: ${cause instanceof Error ? cause.message : String(cause)}`);
+        }
+    };
+    return { list, record };
+};

package/dist/native/AppleSwiftDispatchFacets.js

@@ -0,0 +1,156 @@
+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. */
+export const createSwiftRelativeReader = (input) => {
+    const { bytes, readers: read, budget, result } = input;
+    return (field, indirectable = false) => {
+        const displacement = bytes.readInt32LE(read.offset(field, 4));
+        const indirect = indirectable && (displacement & 1) !== 0;
+        let target = displacement === 0
+            ? 0n
+            : field + BigInt(indirectable ? displacement & ~1 : displacement);
+        let fileOffset = null;
+        let reason = null;
+        try {
+            if (indirect && target !== 0n)
+                target = read.pointer(target);
+            if (target !== 0n)
+                fileOffset = read.offset(target);
+        }
+        catch (cause) {
+            reason = cause instanceof Error ? cause.message : String(cause);
+        }
+        if (budget.admit())
+            result.relative_pointers.push({
+                field: read.location(field),
+                target: {
+                    address: target === 0n ? null : hex(target),
+                    file_offset: fileOffset,
+                },
+                displacement,
+                indirectable,
+                indirect,
+                decode: reason === null ? decoded : { status: "partial", reason },
+                evidence: read.evidence(field, "Swift ABI signed-relative metadata pointer"),
+            });
+        if (reason !== null)
+            throw new RangeError(reason);
+        return target;
+    };
+};
+/** Decode `__swift5_proto` conformances and static witness slots into `result`. */
+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");
+        for (let index = 0; index < section.size / 4; index++) {
+            if (!budget.admit())
+                break;
+            swiftExamined++;
+            const field = section.address + BigInt(index * 4);
+            try {
+                const descriptor = relative(field);
+                const flags = read.u32(descriptor + 12n);
+                const protocol = relative(descriptor, true);
+                if ((read.u32(protocol) & 31) !== 3)
+                    throw new TypeError("Unsupported Swift protocol descriptor kind");
+                const protocolName = read.string(relative(protocol + 8n));
+                const typeKind = (flags >>> 3) & 7;
+                if (typeKind !== 0 && typeKind !== 1)
+                    throw new TypeError("Unsupported Swift conformance type-reference kind");
+                let type = relative(descriptor + 4n);
+                if (typeKind === 1)
+                    type = read.pointer(type);
+                if (![16, 17, 18].includes(read.u32(type) & 31))
+                    throw new TypeError("Unsupported Swift type descriptor kind");
+                const typeName = read.string(relative(type + 8n));
+                const witness = relative(descriptor + 8n);
+                const staticWitness = witness !== 0n &&
+                    (flags & ~0x38) === 0 &&
+                    (read.u32(type) & 0x80) === 0;
+                let witnessReason = staticWitness
+                    ? null
+                    : "Conditional, generic, resilient or missing static witness table is not decoded";
+                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,
+                    module: null,
+                    witness_table: witness === 0n
+                        ? { address: null, file_offset: null }
+                        : read.location(witness),
+                    location: read.location(descriptor),
+                    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);
+                const signatureCount = read.u32(protocol + 12n);
+                if (count > 20_000 || signatureCount > 20_000)
+                    throw new RangeError("Swift witness requirement count exceeds 20000");
+                for (let slot = 0; slot < count; slot++) {
+                    if (!budget.admit())
+                        break;
+                    const entry = witness + BigInt((slot + 1) * 8);
+                    const implementation = read.pointer(entry);
+                    const requirementFlags = read.u32(protocol + 24n + BigInt(signatureCount * 12 + slot * 8));
+                    const kind = requirementFlags & 15;
+                    const synchronousFunction = kind >= 1 && kind <= 4 && (requirementFlags & 0x20) === 0;
+                    const executable = synchronousFunction &&
+                        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",
+                        slot_index: slot + 1,
+                        requirement: null,
+                        implementation: null,
+                        implementation_address: executable ? hex(implementation) : null,
+                        thunk_address: null,
+                        location: read.location(entry),
+                        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) {
+                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)));
+            }
+        }
+    }
+    return {
+        facet: "swift_conformances_static_witness_slots",
+        examined: swiftExamined,
+        decoded: decodedRecords,
+        exhaustive: !budget.truncated && issues.length === 0,
+        issues,
+    };
+};

package/dist/native/AppleSwiftVtables.js

@@ -0,0 +1,92 @@
+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++;
+        try {
+            const descriptor = read.relative(field);
+            const flags = read.u32(descriptor);
+            if ((flags & 31) !== 16)
+                continue;
+            const specific = flags >>> 16;
+            if ((flags & 0x80) !== 0 || (specific & 0x2000) !== 0)
+                throw new TypeError("Generic class or resilient superclass metadata is unsupported");
+            if ((specific & 0x8000) === 0)
+                continue;
+            const initialization = specific & 3;
+            if (initialization === 3)
+                throw new TypeError("Unknown metadata initialization kind");
+            const header = descriptor +
+                44n +
+                BigInt(initialization === 1 ? 12 : initialization === 2 ? 4 : 0);
+            const tableOffset = read.u32(header);
+            const count = read.u32(header + 4n);
+            const positiveWords = read.u32(descriptor + 28n);
+            if (count > 20000 || tableOffset + count > positiveWords)
+                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 methodFlags = read.u32(entry);
+                // Async slots reference async descriptors; coroutine and future kinds need separate decoders.
+                const synchronous = (methodFlags & 0x40) === 0 && (methodFlags & 15) <= 3;
+                const implementation = read.relative(entry + 4n);
+                const resolved = synchronous && read.executable(implementation);
+                result.swift_dispatch_slots.push({
+                    owner,
+                    table_kind: "class_vtable",
+                    slot_index: tableOffset + index,
+                    requirement: null,
+                    implementation: null,
+                    implementation_address: resolved
+                        ? `0x${implementation.toString(16)}`
+                        : null,
+                    thunk_address: null,
+                    location: read.location(entry),
+                    decode: resolved
+                        ? { status: "decoded", reason: null }
+                        : {
+                            status: "partial",
+                            reason: "Async, coroutine, external or unmapped vtable implementation is unresolved",
+                        },
+                    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) {
+                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) {
+            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)}`));
+        }
+    }
+    return {
+        facet: "swift_class_vtable_descriptors",
+        examined,
+        decoded,
+        exhaustive: issues.length === 0,
+        issues,
+    };
+};