fix(native): mark Objective-C declarations partial when the budget cuts their methods

inspect-native-dispatch-metadata returned protocols, classes and categories
with decode status "decoded" and a short or empty method list when the
max_records budget stopped inside that list, which made a truncated list
indistinguishable from a genuinely empty one. Each method-list reader now
reports whether the budget stopped it, and the declaring record reports
partial / method_list_record_budget_exhausted.

Fixes #5543

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/domain/swiftSymbolClassification.ts

@@ -38,12 +38,7 @@ export const classifySwiftSymbol = (
   let category: SwiftTypeCategory | null = null;
   for (;;) {
     const end = identifierEnd(mangling, offset);
-    if (end === undefined) {
-      // A word-substituted or punycode identifier (`0…`) may name a nested
-      // type of any kind, so the enclosing nominal no longer decides it.
-      if (mangling.charAt(offset) === "0") category = null;
-      break;
-    }
+    if (end === undefined) break;
     const kind = mangling.charAt(end);
     const nominal = NOMINAL_CATEGORIES.get(kind);
     if (nominal === undefined) {

src/domain/symbolAnalysis.test.ts

@@ -28,10 +28,6 @@ describe("modern Swift category evidence", () => {
       "$sSi4mainE7doubledSiyF",
       "$s9999999999999999999999BadVMa",
       "$s4main04PairVMa",
-      // Nested types named by punycode identifiers inside struct Envelope.
-      "_$s6Nested8EnvelopeV007IhuqBAbO8describeSSyF",
-      "_$s6Nested8EnvelopeV007jvrtDBlCAEycfC",
-      "_$s6Nested8EnvelopeV007jvrtDBlCMa",
     ];
     const result = categorizeSwiftTypes(
       names.map((name, index) => ({ address: String(index), name })),
@@ -56,16 +52,6 @@ describe("modern Swift category evidence", () => {
     ).toMatchObject({ total: 0, unclassified: [] });
   });
 
-  it("keeps a nested punycode class unresolved under a class filter", () => {
-    const name = "_$s6Nested8EnvelopeV007jvrtDBlCMa";
-    expect(
-      categorizeSwiftTypes([{ address: "0x1", name }], { category: "classes" }),
-    ).toMatchObject({
-      total: 0,
-      unclassified: [{ name, reason: "category_not_decoded" }],
-    });
-  });
-
   it("deduplicates display names after selecting a category", () => {
     expect(
       categorizeSwiftTypes(

src/native/AppleDispatchMetadata.test.ts

@@ -1193,3 +1193,44 @@ describe("malformed Objective-C protocol method lists", () => {
     });
   });
 });
+
+describe("Objective-C method lists cut by the record budget", () => {
+  it("never reports a declaration decoded while the budget omitted its methods", () => {
+    const complete = decodeAppleDispatchMetadata(fixture(), 100, provenance);
+    const classKey = (item: { name: string; is_meta_class: boolean | null }) =>
+      `${item.name}:${String(item.is_meta_class)}`;
+    const completeProtocols = new Map(
+      complete.objc_protocol_records.map((item) => [item.name, item]),
+    );
+    const completeClasses = new Map(
+      complete.objc_classes.map((item) => [classKey(item), item]),
+    );
+    const cutReasons = new Set<string>();
+    for (let budget = 1; budget < 40; budget++) {
+      const result = decodeAppleDispatchMetadata(fixture(), budget, provenance);
+      for (const record of result.objc_protocol_records) {
+        const full = completeProtocols.get(record.name);
+        if (record.decode.status === "decoded") {
+          expect(record.methods).toEqual(full?.methods);
+          expect(record.optional_methods).toEqual(full?.optional_methods);
+        } else if (record.decode.reason !== null)
+          cutReasons.add(`protocol:${record.decode.reason}`);
+      }
+      for (const record of result.objc_classes) {
+        const full = completeClasses.get(classKey(record));
+        if (record.decode?.status === "decoded")
+          expect(record.methods).toEqual(full?.methods);
+        else if (record.decode?.reason != null)
+          cutReasons.add(`class:${record.decode.reason}`);
+      }
+    }
+    // The fixture has methods on both declaration kinds, so some budget must
+    // admit each declaration but stop inside its method list.
+    expect([...cutReasons]).toEqual(
+      expect.arrayContaining([
+        "protocol:method_list_record_budget_exhausted",
+        "class:method_list_record_budget_exhausted",
+      ]),
+    );
+  });
+});

src/native/AppleObjcCategories.ts

@@ -31,7 +31,7 @@ export const decodeObjcCategories = (input: {
     className: string,
     methodType: "instance" | "class",
     category: string,
-  ) => string[];
+  ) => { selectors: string[]; budgetExhausted: boolean };
   readonly protocols: (list: bigint) => string[];
   /** Name of a class defined in this image, from its class_ro_t. */
   readonly localClassName: (address: bigint) => string;
@@ -71,6 +71,18 @@ export const decodeObjcCategories = (input: {
             );
           }
         const owner = className ?? `(${name})`;
+        const instanceMethods = input.methods(
+          read.pointer(category + 16n),
+          owner,
+          "instance",
+          name,
+        );
+        const classMethods = input.methods(
+          read.pointer(category + 24n),
+          owner,
+          "class",
+          name,
+        );
         result.objc_categories.push({
           name,
           class_name: className,
@@ -80,18 +92,8 @@ export const decodeObjcCategories = (input: {
               : className === null
                 ? "unresolved"
                 : "local",
-          instance_methods: input.methods(
-            read.pointer(category + 16n),
-            owner,
-            "instance",
-            name,
-          ),
-          class_methods: input.methods(
-            read.pointer(category + 24n),
-            owner,
-            "class",
-            name,
-          ),
+          instance_methods: instanceMethods.selectors,
+          class_methods: classMethods.selectors,
           protocols: input.protocols(read.pointer(category + 32n)),
           properties: readObjcPropertiesOf(read, read.pointer(category + 40n), {
             owner: `category ${name}`,
@@ -101,9 +103,14 @@ export const decodeObjcCategories = (input: {
           }),
           location: read.location(category),
           decode:
-            className === null
-              ? { status: "partial", reason: "category_class_unresolved" }
-              : { status: "decoded", reason: null },
+            instanceMethods.budgetExhausted || classMethods.budgetExhausted
+              ? {
+                  status: "partial",
+                  reason: "method_list_record_budget_exhausted",
+                }
+              : className === null
+                ? { status: "partial", reason: "category_class_unresolved" }
+                : { status: "decoded", reason: null },
           evidence: read.evidence(category, "Objective-C category_t record"),
         });
       } catch (cause: unknown) {

src/native/AppleObjcDispatchFacets.ts

@@ -103,9 +103,9 @@ export const decodeObjcDispatchFacets = (input: {
     className: string,
     methodType: "instance" | "class",
     category?: string,
-  ): string[] => {
+  ): { selectors: string[]; budgetExhausted: boolean } => {
     const selectors: string[] = [];
-    if (list === 0n) return selectors;
+    if (list === 0n) return { selectors, budgetExhausted: false };
     const flags = read.u32(list),
       count = read.u32(list + 4n),
       relative = (flags & 0x80000000) !== 0;
@@ -113,7 +113,7 @@ export const decodeObjcDispatchFacets = (input: {
     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;
+      if (!budget.admit()) return { selectors, budgetExhausted: true };
       const entry = list + 8n + BigInt(index * stride);
       const rel = (field: bigint) => {
         const displacement = bytes.readInt32LE(read.offset(field, 4));
@@ -196,7 +196,7 @@ export const decodeObjcDispatchFacets = (input: {
         ),
       });
     }
-    return selectors;
+    return { selectors, budgetExhausted: false };
   };
   const protocolReader = createObjcProtocolReader({
     readers: {
@@ -326,7 +326,11 @@ export const decodeObjcDispatchFacets = (input: {
         });
       }
     }
-    methods(read.pointer(ro + 32n), name, meta ? "class" : "instance");
+    const { budgetExhausted } = methods(
+      read.pointer(ro + 32n),
+      name,
+      meta ? "class" : "instance",
+    );
     result.objc_classes.push({
       name,
       super_class: superclass.name,
@@ -362,8 +366,9 @@ export const decodeObjcDispatchFacets = (input: {
       location: read.location(address),
       superclass_address: superclass.address,
       metaclass_address: meta ? null : hex(read.pointer(address)),
-      decode:
-        superclass.name === null && !root
+      decode: budgetExhausted
+        ? { status: "partial", reason: "method_list_record_budget_exhausted" }
+        : superclass.name === null && !root
           ? { status: "partial", reason: "superclass_binding_unresolved" }
           : decoded,
       evidence: read.evidence(

src/native/AppleObjcProtocols.ts

@@ -39,6 +39,8 @@ export const createObjcProtocolReader = (input: {
     instance: boolean,
     /** Entries skipped for an empty selector, reported by the declaring protocol. */
     emptySelectors: string[],
+    /** Set when the record budget stops the list before its last entry. */
+    budget: { exhausted: boolean },
   ) => {
     const output: ObjcSwiftMetadata["objc_protocols"][number]["methods"] = [];
     if (address === 0n) return output;
@@ -49,7 +51,10 @@ export const createObjcProtocolReader = (input: {
     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;
+      if (!read.admit()) {
+        budget.exhausted = true;
+        break;
+      }
       const entry = address + 8n + BigInt(index * stride);
       let selector = relative
         ? entry + BigInt(read.i32(entry))
@@ -88,13 +93,14 @@ export const createObjcProtocolReader = (input: {
       if (protocolName.length === 0)
         throw new TypeError("Objective-C protocol has an empty name");
       const skipped: string[] = [];
+      const budget = { exhausted: false };
       const required = [
-        ...methods(read.pointer(address + 24n), true, true, skipped),
-        ...methods(read.pointer(address + 32n), true, false, skipped),
+        ...methods(read.pointer(address + 24n), true, true, skipped, budget),
+        ...methods(read.pointer(address + 32n), true, false, skipped, budget),
       ];
       const optional = [
-        ...methods(read.pointer(address + 40n), false, true, skipped),
-        ...methods(read.pointer(address + 48n), false, false, skipped),
+        ...methods(read.pointer(address + 40n), false, true, skipped, budget),
+        ...methods(read.pointer(address + 48n), false, false, skipped, budget),
       ];
       for (const message of skipped)
         failures.push(
@@ -112,8 +118,11 @@ export const createObjcProtocolReader = (input: {
         methods: required,
         optional_methods: optional,
         location: read.location(address),
-        decode:
-          skipped.length === 0
+        // A budget-cut list is recoverable with a larger budget, so that
+        // cause is reported first; an empty list is otherwise complete.
+        decode: budget.exhausted
+          ? { status: "partial", reason: "method_list_record_budget_exhausted" }
+          : skipped.length === 0
             ? { status: "decoded", reason: null }
             : { status: "partial", reason: "protocol_method_selector_empty" },
         evidence: read.evidence(

tests/boundary/providers/kuna/kunaDoctor.test.ts

@@ -176,13 +176,7 @@ it.each(["caller", "host"] as const)(
     );
     let closing: ReturnType<NonNullable<typeof host.close>> | undefined;
     try {
-      // The preceding Ghidra probe may prepare Darwin process ownership before
-      // Kuna starts; keep startup separate from the bounded post-abort join.
-      await expect
-        .poll(async () => (await fakeKunaCalls(kuna)).length, {
-          timeout: 10_000,
-        })
-        .toBe(1);
+      await expect.poll(async () => (await fakeKunaCalls(kuna)).length).toBe(1);
       const probe = (await fakeKunaCalls(kuna))[0];
       if (probe === undefined) throw new Error("Missing Kuna version probe");
       expect(probe.argv).toEqual(["--version"]);