rea-agents 3.1.0 → 3.2.1

package/bridge/ghidra/ReaGhidraBridge.java

@@ -5,7 +5,6 @@ import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.io.Reader;
 import java.math.BigInteger;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
@@ -26,8 +25,11 @@ import java.security.MessageDigest;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.regex.Pattern;
@@ -75,32 +77,17 @@ import ghidra.program.model.pcode.FunctionPrototype;
 import ghidra.program.model.pcode.HighFunction;
 import ghidra.program.model.pcode.HighSymbol;
 import ghidra.program.model.pcode.JumpTable;
+import ghidra.program.model.pcode.PcodeOp;
+import ghidra.program.model.pcode.PcodeOpAST;
+import ghidra.program.model.pcode.Varnode;
+import ghidra.program.model.pcode.VarnodeAST;
 
 public final class ReaGhidraBridge extends HeadlessScript {
-    private static final int BRIDGE_VERSION = 6;
-    private static final int MAX_DESCRIPTOR_BYTES = 16 * 1024;
-    private static final int MAX_REQUEST_CHARACTERS = 256 * 1024;
-    private static final int MAX_RESPONSE_BYTES = 1024 * 1024;
-    private static final int RESPONSE_ENVELOPE_RESERVE_BYTES = 32 * 1024;
-    private static final int MAX_NATIVE_API_RESPONSE_BYTES = 192 * 1024;
-    private static final int MAX_INVENTORY_ITEMS = 1_000_000;
-    private static final int MAX_FUNCTION_ITEMS = 100_000;
-    private static final int MAX_FUNCTION_INSTRUCTIONS = 100_000;
-    private static final int MAX_NATIVE_API_PARAMETERS = 64;
-    private static final int MAX_NATIVE_API_JUMP_TABLES = 4;
-    private static final int MAX_NATIVE_API_LOAD_TABLES = 4;
-    private static final int MAX_NATIVE_API_MAPPINGS = 32;
-    private static final int DECOMPILE_TIMEOUT_SECONDS = 30;
-    private static final int DECOMPILE_PAYLOAD_MBYTES = 8;
-    private static final int MAX_LIST_VALUE_CODE_POINTS = 1_024;
-    private static final int MAX_SEARCH_VALUE_CODE_POINTS = 4_096;
-    private static final int MAX_REGEX_CANDIDATE_CHARACTERS = 4_096;
-    private static final long MAX_REGEX_BACKTRACKING_PATHS = 10_000;
-    private static final long MAX_LITERAL_SEARCH_WORK_UNITS = 1_000_000;
-    private static final long MAX_REGEX_SEARCH_WORK_UNITS = 1_000_000;
+    private static final int MAX_HIGH_PCODE_OPS = 3000;
+    private static final int MAX_HIGH_PCODE_INPUTS_PER_OP = 64;
+    private static final int MAX_HIGH_PCODE_DEF_USE_EDGES = 12000;
     private static final Gson GSON = new GsonBuilder().serializeNulls().create();
     private static final Set<String> DESCRIPTOR_KEYS = Set.of(
-        "schema_version",
         "transport",
         "endpoint_path",
         "token",
@@ -218,7 +205,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
             server.bind(new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 0));
             InetSocketAddress address = (InetSocketAddress) server.getLocalAddress();
             JsonObject endpoint = new JsonObject();
-            endpoint.addProperty("schema_version", 1);
             endpoint.addProperty("host", "127.0.0.1");
             endpoint.addProperty("port", address.getPort());
             Files.writeString(
@@ -261,7 +247,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
             BufferedReader reader,
             BufferedWriter writer) throws Exception {
         while (true) {
-            String line = readBoundedLine(reader, MAX_REQUEST_CHARACTERS);
+            String line = reader.readLine();
             if (line == null) {
                 return;
             }
@@ -359,7 +345,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
 
         JsonObject result = new JsonObject();
         result.addProperty("name", "REA Ghidra bridge");
-        result.addProperty("bridge_version", BRIDGE_VERSION);
         result.addProperty("run_id", descriptor.runId);
         result.addProperty("profile_digest", descriptor.profileDigest);
         result.add("provider", provider);
@@ -373,9 +358,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
 
     private void initializeDecompiler() {
         DecompileOptions options = new DecompileOptions();
-        options.setDefaultTimeout(DECOMPILE_TIMEOUT_SECONDS);
-        options.setMaxPayloadMBytes(DECOMPILE_PAYLOAD_MBYTES);
-        options.setMaxInstructions(MAX_FUNCTION_INSTRUCTIONS);
+        options.setMaxInstructions(Integer.MAX_VALUE);
         decompiler = new DecompInterface();
         decompiler.setOptions(options);
         decompiler.toggleCCode(true);
@@ -398,43 +381,19 @@ public final class ReaGhidraBridge extends HeadlessScript {
         requireKeys(params, Set.of("document", "procedure"));
         requireDocument(params);
         Function function = resolveProcedure(requireString(params, "procedure"));
-        InstructionScan scan = scanInstructions(function, MAX_FUNCTION_INSTRUCTIONS);
-        if (scan.truncated) {
-            throw functionLimit("Procedure assembly exceeds the 100000-instruction limit");
-        }
+        InstructionScan scan = scanInstructions(function, Integer.MAX_VALUE);
         return GSON.toJsonTree(renderAssembly(scan.instructions));
     }
 
     private JsonObject readFunctionInstructions(JsonObject params) throws Exception {
-        requireKeys(params, Set.of("document", "procedure", "offset", "limit"));
+        requireKeys(params, Set.of("document", "procedure"));
         requireDocument(params);
         Function function = resolveProcedure(requireString(params, "procedure"));
-        int offset = requireBoundedInteger(params, "offset", 0, 100_000);
-        int limit = requireBoundedInteger(params, "limit", 1, 500);
-        InstructionScan scan = scanInstructions(function, offset + limit + 1);
-        int start = Math.min(offset, scan.instructions.size());
-        int end = Math.min(scan.instructions.size(), start + limit);
+        InstructionScan scan = scanInstructions(function, Integer.MAX_VALUE);
         JsonArray items = new JsonArray();
-        for (String line : renderAssemblyLines(scan.instructions.subList(start, end))) {
+        for (String line : renderAssemblyLines(scan.instructions)) {
             items.add(line);
         }
-        boolean hasMore = scan.truncated || end < scan.instructions.size();
-        JsonObject instructions = new JsonObject();
-        instructions.add("items", items);
-        if (scan.truncated) {
-            instructions.add("total", JsonNull.INSTANCE);
-        }
-        else {
-            instructions.addProperty("total", scan.instructions.size());
-        }
-        instructions.addProperty("returned", items.size());
-        instructions.addProperty("truncated", hasMore);
-        if (hasMore) {
-            instructions.addProperty("next_offset", end);
-        }
-        else {
-            instructions.add("next_offset", JsonNull.INSTANCE);
-        }
 
         JsonArray limitations = new JsonArray();
         limitations.add("Instruction text and ordering are Ghidra-specific representations.");
@@ -443,9 +402,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
         );
         JsonObject result = new JsonObject();
         result.add("procedure", procedureIdentity(function));
-        result.add("instructions", instructions);
-        result.addProperty("instructions_scanned", scan.instructions.size());
-        result.addProperty("instruction_scan_truncated", scan.truncated);
+        result.add("instructions", items);
         result.add("limitations", limitations);
         return result;
     }
@@ -457,9 +414,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
         Set<Function> observed = callers
             ? function.getCallingFunctions(monitor)
             : function.getCalledFunctions(monitor);
-        if (observed.size() > MAX_FUNCTION_ITEMS) {
-            throw functionLimit("Resolved call set exceeds the 100000-item limit");
-        }
         List<Function> ordered = new ArrayList<>(observed);
         ordered.sort(Comparator.comparing(Function::getEntryPoint));
         JsonArray result = new JsonArray();
@@ -490,10 +444,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
             Set.of(
                 "document",
                 "procedure",
-                "direction",
-                "offset",
-                "limit",
-                "max_instructions"
+                "direction"
             )
         );
         requireDocument(params);
@@ -502,10 +453,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
         if (!direction.equals("incoming") && !direction.equals("outgoing")) {
             throw new RequestFailure("invalid_request", "direction must be incoming or outgoing");
         }
-        int offset = requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE);
-        int limit = requireBoundedInteger(params, "limit", 1, 500);
-        int maximum = requireBoundedInteger(params, "max_instructions", 1, 5_000);
-        InstructionScan scan = scanInstructions(function, maximum);
+        InstructionScan scan = scanInstructions(function, Integer.MAX_VALUE);
         List<Reference> references = collectReferences(scan.instructions, direction);
         JsonArray edges = new JsonArray();
         for (Reference reference : references) {
@@ -514,9 +462,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
         JsonObject result = new JsonObject();
         result.add("procedure", procedureIdentity(function));
         result.addProperty("direction", direction);
-        result.add("references", bounded(edges, offset, limit, !scan.truncated));
-        result.addProperty("instructions_scanned", scan.instructions.size());
-        result.addProperty("instruction_scan_truncated", scan.truncated);
+        result.add("references", edges);
         return result;
     }
 
@@ -533,10 +479,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
                 continue;
             }
             sources.add(reference.getFromAddress());
-            if (sources.size() > MAX_FUNCTION_ITEMS) {
-                throw functionLimit("Cross-reference set exceeds the 100000-item limit");
             }
-        }
         List<Address> ordered = new ArrayList<>(sources);
         ordered.sort(Address::compareTo);
         JsonArray result = new JsonArray();
@@ -547,48 +490,9 @@ public final class ReaGhidraBridge extends HeadlessScript {
     }
 
     private JsonObject analyzeFunction(JsonObject params) throws Exception {
-        requireKeys(
-            params,
-            Set.of(
-                "procedure",
-                "include_assembly",
-                "limit",
-                "max_pseudocode_chars",
-                "max_instructions",
-                "pseudocode_offset",
-                "assembly_offset",
-                "collection_offset"
-            )
-        );
+        requireKeys(params, Set.of("procedure"));
         Function function = resolveProcedure(requireString(params, "procedure"));
-        boolean includeAssembly = requireBoolean(params, "include_assembly");
-        int limit = requireBoundedInteger(params, "limit", 1, 500);
-        int maximumCharacters = requireBoundedInteger(
-            params,
-            "max_pseudocode_chars",
-            1,
-            100_000
-        );
-        int maximumInstructions = requireBoundedInteger(
-            params,
-            "max_instructions",
-            1,
-            5_000
-        );
-        int pseudocodeOffset = requireBoundedInteger(
-            params,
-            "pseudocode_offset",
-            0,
-            Integer.MAX_VALUE
-        );
-        int assemblyOffset = requireBoundedInteger(
-            params,
-            "assembly_offset",
-            0,
-            Integer.MAX_VALUE
-        );
-        JsonObject offsets = requireCollectionOffsets(params);
-        InstructionScan scan = scanInstructions(function, maximumInstructions);
+        InstructionScan scan = scanInstructions(function, Integer.MAX_VALUE);
         DecompileResults decompilation = decompile(function);
         String pseudocode = decompiledText(decompilation);
         if (pseudocode == null) {
@@ -607,88 +511,29 @@ public final class ReaGhidraBridge extends HeadlessScript {
         JsonArray referencedStrings = referencedStrings(outgoingReferences);
         JsonArray referencedNames = referencedNames(outgoingReferences);
         JsonArray blocks = basicBlockValues(function);
-        JsonArray assembly = includeAssembly
-            ? GSON.toJsonTree(renderAssemblyLines(scan.instructions)).getAsJsonArray()
-            : new JsonArray();
+        JsonArray assembly = GSON.toJsonTree(renderAssemblyLines(scan.instructions))
+            .getAsJsonArray();
 
         JsonObject procedure = procedureIdentity(function);
         procedure.addProperty("signature", function.getPrototypeString(false, true));
         procedure.add("locals", functionLocals(function));
         JsonObject result = new JsonObject();
         result.add("procedure", procedure);
-        result.add(
-            "pseudocode",
-            pseudocodePage(pseudocode, pseudocodeOffset, maximumCharacters)
-        );
-        result.add(
-            "assembly",
-            includeAssembly
-                ? bounded(assembly, assemblyOffset, maximumInstructions, !scan.truncated)
-                : bounded(assembly, 0, maximumInstructions, true)
-        );
-        result.add(
-            "comments",
-            bounded(comments, collectionOffset(offsets, "comments"), limit, !scan.truncated)
-        );
-        result.add("callers", bounded(callers, collectionOffset(offsets, "callers"), limit, true));
-        result.add("callees", bounded(callees, collectionOffset(offsets, "callees"), limit, true));
-        result.add(
-            "incoming_references",
-            bounded(
-                incoming,
-                collectionOffset(offsets, "incoming_references"),
-                limit,
-                !scan.truncated
-            )
-        );
-        result.add(
-            "outgoing_references",
-            bounded(
-                outgoing,
-                collectionOffset(offsets, "outgoing_references"),
-                limit,
-                !scan.truncated
-            )
-        );
-        result.add(
-            "referenced_strings",
-            bounded(
-                referencedStrings,
-                collectionOffset(offsets, "referenced_strings"),
-                limit,
-                !scan.truncated
-            )
-        );
-        result.add(
-            "referenced_names",
-            bounded(
-                referencedNames,
-                collectionOffset(offsets, "referenced_names"),
-                limit,
-                !scan.truncated
-            )
-        );
-        result.add(
-            "basic_blocks",
-            bounded(blocks, collectionOffset(offsets, "basic_blocks"), limit, true)
-        );
-        JsonObject instructionScan = new JsonObject();
-        instructionScan.addProperty("scanned", scan.instructions.size());
-        instructionScan.addProperty("truncated", scan.truncated);
-        result.add("instruction_scan", instructionScan);
-        int nativeApiBudget = Math.min(
-            MAX_NATIVE_API_RESPONSE_BYTES,
-            Math.max(
-                0,
-                MAX_RESPONSE_BYTES -
-                encodedUtf8Length(result) -
-                RESPONSE_ENVELOPE_RESERVE_BYTES
-            )
-        );
+        result.addProperty("pseudocode", pseudocode);
+        result.add("assembly", assembly);
+        result.add("comments", comments);
+        result.add("callers", callers);
+        result.add("callees", callees);
+        result.add("incoming_references", incoming);
+        result.add("outgoing_references", outgoing);
+        result.add("referenced_strings", referencedStrings);
+        result.add("referenced_names", referencedNames);
+        result.add("basic_blocks", blocks);
         result.add(
             "native_api",
-            nativeApiBoundary(function, decompilation, nativeApiBudget)
+            nativeApiBoundary(function, decompilation)
         );
+        result.add("native_value_flow", nativeValueFlow(decompilation));
         JsonArray limitations = new JsonArray();
         limitations.add(
             "Unresolved computed or indirect flows without target addresses are not represented as reference edges."
@@ -706,6 +551,205 @@ public final class ReaGhidraBridge extends HeadlessScript {
         return result;
     }
 
+    private JsonObject nativeValueFlow(DecompileResults decompilation) throws Exception {
+        HighFunction highFunction =
+            decompilation == null ? null : decompilation.getHighFunction();
+        if (highFunction == null) {
+            JsonObject unavailable = new JsonObject();
+            unavailable.addProperty("available", false);
+            unavailable.addProperty(
+                "reason",
+                "Ghidra has no HighFunction p-code model for this procedure"
+            );
+            JsonArray limitations = new JsonArray();
+            limitations.add(
+                "No p-code operations or def-use relationships were recovered for this procedure."
+            );
+            unavailable.add("limitations", limitations);
+            return unavailable;
+        }
+
+        List<PcodeOpAST> selected = new ArrayList<>();
+        int omittedOperationsLowerBound = 0;
+        Iterator<PcodeOpAST> operations = highFunction.getPcodeOps();
+        while (operations.hasNext()) {
+            monitor.checkCancelled();
+            PcodeOpAST operation = operations.next();
+            if (selected.size() >= MAX_HIGH_PCODE_OPS) {
+                omittedOperationsLowerBound = 1;
+                break;
+            }
+            selected.add(operation);
+        }
+
+        Map<PcodeOpAST, String> operationIds = new IdentityHashMap<>();
+        for (PcodeOpAST operation : selected) {
+            operationIds.put(operation, pcodeOperationId(operation));
+        }
+        JsonArray operationValues = new JsonArray();
+        JsonArray defUse = new JsonArray();
+        JsonArray effects = new JsonArray();
+        int omittedInputs = 0;
+        int omittedEdges = 0;
+        for (PcodeOpAST operation : selected) {
+            monitor.checkCancelled();
+            String operationId = operationIds.get(operation);
+            JsonObject value = new JsonObject();
+            value.addProperty("id", operationId);
+            value.addProperty(
+                "address",
+                canonicalAddress(operation.getSeqnum().getTarget())
+            );
+            value.addProperty("sequence", operation.getSeqnum().getTime());
+            value.addProperty("opcode", operation.getMnemonic());
+            value.addProperty("is_dead", operation.isDead());
+            JsonArray inputs = new JsonArray();
+            int inputCount = operation.getNumInputs();
+            int capturedInputs = Math.min(inputCount, MAX_HIGH_PCODE_INPUTS_PER_OP);
+            for (int inputIndex = 0; inputIndex < capturedInputs; inputIndex += 1) {
+                Varnode input = operation.getInput(inputIndex);
+                inputs.add(varnodeValue(input));
+                if (input instanceof VarnodeAST astInput) {
+                    PcodeOp definition = astInput.getDef();
+                    if (definition instanceof PcodeOpAST astDefinition) {
+                        String definitionId = operationIds.get(astDefinition);
+                        if (definitionId == null || defUse.size() >= MAX_HIGH_PCODE_DEF_USE_EDGES) {
+                            omittedEdges += 1;
+                        } else {
+                            JsonObject edge = new JsonObject();
+                            edge.addProperty("definition", definitionId);
+                            edge.addProperty("use", operationId);
+                            edge.addProperty("input_index", inputIndex);
+                            defUse.add(edge);
+                        }
+                    }
+                }
+            }
+            omittedInputs += inputCount - capturedInputs;
+            value.add("inputs", inputs);
+            Varnode output = operation.getOutput();
+            value.add("output", output == null ? JsonNull.INSTANCE : varnodeValue(output));
+            operationValues.add(value);
+            addPcodeEffect(effects, operation, operationId);
+        }
+
+        JsonObject result = new JsonObject();
+        result.addProperty("available", true);
+        result.addProperty("provenance", "ghidra-high-pcode");
+        result.add("operations", operationValues);
+        result.add("def_use", defUse);
+        result.add("effects", effects);
+        boolean truncated = omittedOperationsLowerBound > 0 ||
+            omittedInputs > 0 || omittedEdges > 0;
+        result.addProperty("truncated", truncated);
+        result.addProperty(
+            "omitted_operations_lower_bound",
+            omittedOperationsLowerBound
+        );
+        result.addProperty("known_omitted_inputs", omittedInputs);
+        result.addProperty("known_omitted_edges", omittedEdges);
+        JsonArray limitations = new JsonArray();
+        limitations.add(
+            "High p-code is a decompiler-derived intra-function representation, not original source or runtime behavior; dead operations are retained and marked."
+        );
+        limitations.add(
+            "Def-use links do not cross function boundaries and may omit memory aliasing, call side effects, or unresolved indirect flow."
+        );
+        limitations.add(
+            "Memory read/write effects include stack and temporary memory operations; they do not identify persistent state or business meaning."
+        );
+        limitations.add(
+            "Operation, input, and def-use limits can truncate large functions; inspect truncation, omitted lower bounds, and known omitted counts before drawing conclusions."
+        );
+        limitations.add(
+            "Known omitted-edge counts cover links omitted from retained operations; omitted operations may contain additional uncounted links."
+        );
+        result.add("limitations", limitations);
+        return result;
+    }
+
+    private String pcodeOperationId(PcodeOpAST operation) {
+        return canonicalAddress(operation.getSeqnum().getTarget()) + "#" +
+            operation.getSeqnum().getTime();
+    }
+
+    private JsonObject varnodeValue(Varnode varnode) {
+        JsonObject result = new JsonObject();
+        String kind = varnode.isConstant()
+            ? "constant"
+            : varnode.isAddress()
+                ? "address"
+                : varnode.isRegister()
+                    ? "register"
+                    : varnode.isUnique() ? "unique" : "other";
+        result.addProperty("kind", kind);
+        result.addProperty("size_bytes", varnode.getSize());
+        result.add(
+            "location",
+            varnode.isConstant()
+                ? JsonNull.INSTANCE
+                : GSON.toJsonTree(canonicalAddress(varnode.getAddress()))
+        );
+        result.add(
+            "constant_hex",
+            varnode.isConstant()
+                ? GSON.toJsonTree(Long.toUnsignedString(varnode.getOffset(), 16))
+                : JsonNull.INSTANCE
+        );
+        return result;
+    }
+
+    private void addPcodeEffect(
+        JsonArray destination,
+        PcodeOp operation,
+        String operationId
+    ) {
+        String kind = null;
+        Integer operandInput = null;
+        Integer valueInput = null;
+        switch (operation.getOpcode()) {
+            case PcodeOp.LOAD -> {
+                kind = "memory_read";
+                operandInput = 1;
+            }
+            case PcodeOp.STORE -> {
+                kind = "memory_write";
+                operandInput = 1;
+                valueInput = 2;
+            }
+            case PcodeOp.CBRANCH -> {
+                kind = "conditional_branch";
+                valueInput = 1;
+            }
+            case PcodeOp.BRANCHIND -> {
+                kind = "indirect_branch";
+                operandInput = 0;
+            }
+            case PcodeOp.CALL -> {
+                kind = "direct_call";
+                operandInput = 0;
+            }
+            case PcodeOp.CALLIND -> {
+                kind = "indirect_call";
+                operandInput = 0;
+            }
+            default -> { }
+        }
+        if (kind == null) return;
+        JsonObject effect = new JsonObject();
+        effect.addProperty("operation", operationId);
+        effect.addProperty("kind", kind);
+        effect.add(
+            "operand_input",
+            operandInput == null ? JsonNull.INSTANCE : GSON.toJsonTree(operandInput)
+        );
+        effect.add(
+            "value_input",
+            valueInput == null ? JsonNull.INSTANCE : GSON.toJsonTree(valueInput)
+        );
+        destination.add(effect);
+    }
+
     private JsonElement addressName(JsonObject params) {
         requireKeys(params, Set.of("document", "address"));
         requireDocument(params);
@@ -721,8 +765,8 @@ public final class ReaGhidraBridge extends HeadlessScript {
         return result;
     }
 
-    private JsonObject listNames(JsonObject params) throws Exception {
-        requireKeys(params, Set.of("document", "address", "offset", "limit"));
+    private JsonArray listNames(JsonObject params) throws Exception {
+        requireKeys(params, Set.of("document", "address"));
         requireDocument(params);
         List<InventoryItem> inventory = names();
         String requested = optionalString(params, "address");
@@ -732,26 +776,16 @@ public final class ReaGhidraBridge extends HeadlessScript {
                 .filter(item -> item.address.equals(address))
                 .toList();
         }
-        return page(
-            inventory,
-            requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE),
-            requireBoundedInteger(params, "limit", 1, 500),
-            "symbol"
-        );
+        return inventory(inventory, "symbol");
     }
 
-    private JsonObject listProcedures(JsonObject params) throws Exception {
-        requireKeys(params, Set.of("document", "offset", "limit"));
+    private JsonArray listProcedures(JsonObject params) throws Exception {
+        requireKeys(params, Set.of("document"));
         requireDocument(params);
         List<InventoryItem> inventory = procedures().stream()
             .map(FunctionEntry::item)
             .toList();
-        return page(
-            inventory,
-            requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE),
-            requireBoundedInteger(params, "limit", 1, 500),
-            "procedure"
-        );
+        return inventory(inventory, "procedure");
     }
 
     private JsonArray listSegments(JsonObject params) {
@@ -760,9 +794,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
         JsonArray result = new JsonArray();
         String imageBase = canonicalAddress(currentProgram.getImageBase());
         MemoryBlock[] blocks = currentProgram.getMemory().getBlocks();
-        if (blocks.length > MAX_INVENTORY_ITEMS) {
-            throw inventoryLimit();
-        }
         List<MemoryBlock> ordered = new ArrayList<>(List.of(blocks));
         ordered.sort(Comparator.comparing(MemoryBlock::getStart));
         for (MemoryBlock block : ordered) {
@@ -773,8 +804,8 @@ public final class ReaGhidraBridge extends HeadlessScript {
         return result;
     }
 
-    private JsonObject listStrings(JsonObject params) throws Exception {
-        requireKeys(params, Set.of("document", "address", "offset", "limit"));
+    private JsonArray listStrings(JsonObject params) throws Exception {
+        requireKeys(params, Set.of("document", "address"));
         requireDocument(params);
         List<InventoryItem> inventory = strings();
         String requested = optionalString(params, "address");
@@ -784,12 +815,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
                 .filter(item -> item.address.equals(address))
                 .toList();
         }
-        return page(
-            inventory,
-            requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE),
-            requireBoundedInteger(params, "limit", 1, 500),
-            "string"
-        );
+        return inventory(inventory, "string");
     }
 
     private JsonElement procedureAddress(JsonObject params) throws Exception {
@@ -820,26 +846,18 @@ public final class ReaGhidraBridge extends HeadlessScript {
         return result;
     }
 
-    private JsonObject search(JsonObject params, boolean procedureSearch) throws Exception {
+    private JsonArray search(JsonObject params, boolean procedureSearch) throws Exception {
         requireKeys(
             params,
-            Set.of("pattern", "mode", "case_sensitive", "offset", "limit", "document")
+            Set.of("pattern", "mode", "case_sensitive", "document")
         );
         requireDocument(params);
         String expression = requireString(params, "pattern");
-        if (expression.codePointCount(0, expression.length()) > 256) {
-            throw new RequestFailure(
-                "invalid_request",
-                "pattern must contain between 1 and 256 characters"
-            );
-        }
         String mode = requireString(params, "mode");
         if (!mode.equals("literal") && !mode.equals("regex")) {
             throw new RequestFailure("invalid_request", "mode must be literal or regex");
         }
         boolean caseSensitive = requireBoolean(params, "case_sensitive");
-        int offset = requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE);
-        int limit = requireBoundedInteger(params, "limit", 1, 100);
         List<InventoryItem> inventory = procedureSearch
             ? procedures().stream().map(FunctionEntry::item).toList()
             : strings();
@@ -847,18 +865,13 @@ public final class ReaGhidraBridge extends HeadlessScript {
             ? literalMatcher(expression, caseSensitive)
             : regexMatcher(expression, caseSensitive);
         JsonArray items = new JsonArray();
-        int total = 0;
-        long pageEnd = (long) offset + limit;
         for (InventoryItem item : inventory) {
             if (!matcher.matches(item.value)) {
                 continue;
             }
-            if (total >= offset && total < pageEnd) {
-                items.add(resultItem(item, null, MAX_SEARCH_VALUE_CODE_POINTS));
-            }
-            total += 1;
+            items.add(resultItem(item, null));
         }
-        return pageResult(items, offset, limit, total);
+        return items;
     }
 
     private List<InventoryItem> names() throws Exception {
@@ -880,10 +893,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
             facts.addProperty("external", symbol.isExternal());
             facts.addProperty("type", normalizedSymbolType(symbol));
             facts.addProperty("source", normalizedSource(symbol.getSource()));
-            addBounded(
-                result,
-                new InventoryItem(address, symbol.getName(true), facts)
-            );
+            result.add(new InventoryItem(address, symbol.getName(true), facts));
         }
         result.sort(INVENTORY_ORDER);
         nameInventory = List.copyOf(result);
@@ -929,9 +939,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
                 symbol == null ? function.getName() : symbol.getName(true),
                 facts
             );
-            if (destination.size() >= MAX_INVENTORY_ITEMS) {
-                throw inventoryLimit();
-            }
             destination.add(new FunctionEntry(function, item));
         }
     }
@@ -961,7 +968,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
                 instance.isMissingNullTerminator() ? "missing" : "present_or_not_required"
             );
             facts.addProperty("byte_length", Math.max(0, data.getLength()));
-            addBounded(result, new InventoryItem(data.getAddress(), value, facts));
+            result.add(new InventoryItem(data.getAddress(), value, facts));
         }
         result.sort(INVENTORY_ORDER);
         stringInventory = List.copyOf(result);
@@ -1000,8 +1007,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
 
     private JsonObject nativeApiBoundary(
         Function function,
-        DecompileResults decompilation,
-        int maximumBytes
+        DecompileResults decompilation
     ) throws Exception {
         if (decompilation == null || decompilation.getHighFunction() == null) {
             return unavailableNativeApiBoundary(
@@ -1041,11 +1047,9 @@ public final class ReaGhidraBridge extends HeadlessScript {
 
         JsonArray parameters = new JsonArray();
         result.add("parameters", parameters);
-        result.addProperty("parameters_truncated", false);
 
         JsonArray jumpTables = new JsonArray();
         result.add("jump_tables", jumpTables);
-        result.addProperty("jump_tables_truncated", false);
 
         JsonObject pseudocode = new JsonObject();
         pseudocode.addProperty("classification", "decompiler-generated-non-source");
@@ -1071,17 +1075,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
             "Pseudocode is neither original source nor guaranteed to compile."
         );
         result.add("limitations", limitations);
-        if (encodedUtf8Length(result) > maximumBytes) {
-            return unavailableNativeApiBoundary(
-                "The remaining Ghidra response budget cannot contain a structured native API boundary"
-            );
-        }
-
-        int parameterCount = Math.min(
-            prototype.getNumParams(),
-            MAX_NATIVE_API_PARAMETERS
-        );
-        for (int index = 0; index < parameterCount; index += 1) {
+        for (int index = 0; index < prototype.getNumParams(); index += 1) {
             HighSymbol parameter = prototype.getParam(index);
             if (parameter == null) {
                 continue;
@@ -1097,32 +1091,12 @@ public final class ReaGhidraBridge extends HeadlessScript {
                     signatureSource
                 )
             );
-            if (encodedUtf8Length(result) > maximumBytes) {
-                parameters.remove(parameters.size() - 1);
-                break;
-            }
         }
-        result.addProperty(
-            "parameters_truncated",
-            prototype.getNumParams() > parameters.size()
-        );
 
         JumpTable[] recoveredJumpTables = highFunction.getJumpTables();
-        int jumpTableCount = Math.min(
-            recoveredJumpTables.length,
-            MAX_NATIVE_API_JUMP_TABLES
-        );
-        for (int index = 0; index < jumpTableCount; index += 1) {
+        for (int index = 0; index < recoveredJumpTables.length; index += 1) {
             jumpTables.add(inferredJumpTable(recoveredJumpTables[index]));
-            if (encodedUtf8Length(result) > maximumBytes) {
-                jumpTables.remove(jumpTables.size() - 1);
-                break;
-            }
         }
-        result.addProperty(
-            "jump_tables_truncated",
-            recoveredJumpTables.length > jumpTables.size()
-        );
         return result;
     }
 
@@ -1137,10 +1111,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
         return unavailable;
     }
 
-    private static int encodedUtf8Length(JsonElement value) {
-        return GSON.toJson(value).getBytes(StandardCharsets.UTF_8).length;
-    }
-
     private static JsonObject inferredBoundaryType(
         String role,
         Integer ordinal,
@@ -1228,22 +1198,30 @@ public final class ReaGhidraBridge extends HeadlessScript {
             canonicalAddress(jumpTable.getSwitchAddress())
         );
         JumpTable.LoadTable[] loadTables = jumpTable.getLoadTables();
+        RecoveredAArch64ByteTable recoveredAArch64 =
+            loadTables.length == 0
+                ? recoverAArch64ByteTable(jumpTable)
+                : null;
         List<Address> referencedDataAddresses = loadTables.length == 0
             ? dispatchPathDataReferences(jumpTable)
             : List.of();
         JsonArray dataSources = new JsonArray();
-        int loadTableCount = Math.min(
-            loadTables.length,
-            MAX_NATIVE_API_LOAD_TABLES
-        );
-        for (int index = 0; index < loadTableCount; index += 1) {
+        for (int index = 0; index < loadTables.length; index += 1) {
+            monitor.checkCancelled();
             JumpTable.LoadTable loadTable = loadTables[index];
             JsonObject source = new JsonObject();
             source.addProperty("address", canonicalAddress(loadTable.getAddress()));
             source.addProperty("provenance", "ghidra-decompiler-load-table");
-            source.addProperty("entry_size_bytes", loadTable.getSize());
-            source.addProperty("entry_count", loadTable.getNum());
-            source.addProperty("confidence", "high");
+            int entrySize = loadTable.getSize();
+            int entryCount = loadTable.getNum();
+            if (entrySize > 0) source.addProperty("entry_size_bytes", entrySize);
+            else source.add("entry_size_bytes", JsonNull.INSTANCE);
+            if (entryCount > 0) source.addProperty("entry_count", entryCount);
+            else source.add("entry_count", JsonNull.INSTANCE);
+            source.addProperty(
+                "confidence",
+                entrySize > 0 && entryCount > 0 ? "high" : "medium"
+            );
             JsonArray evidence = new JsonArray();
             evidence.add(
                 inferenceEvidence(
@@ -1257,12 +1235,37 @@ public final class ReaGhidraBridge extends HeadlessScript {
             source.add("evidence", evidence);
             dataSources.add(source);
         }
-        int referencedDataCount = Math.min(
-            referencedDataAddresses.size(),
-            MAX_NATIVE_API_LOAD_TABLES - loadTableCount
-        );
-        for (int index = 0; index < referencedDataCount; index += 1) {
+        if (recoveredAArch64 != null) {
+            JsonObject source = new JsonObject();
+            source.addProperty(
+                "address",
+                canonicalAddress(recoveredAArch64.tableAddress)
+            );
+            source.addProperty("provenance", "ghidra-aarch64-byte-table");
+            source.addProperty("entry_size_bytes", 1);
+            source.addProperty("entry_count", recoveredAArch64.mappings.size());
+            source.addProperty("confidence", "high");
+            JsonArray evidence = new JsonArray();
+            evidence.add(
+                inferenceEvidence(
+                    "jump-table",
+                    "ghidra-instruction-and-memory",
+                    "Decoded " + recoveredAArch64.mappings.size() +
+                    " byte entries from " + canonicalAddress(recoveredAArch64.tableAddress) +
+                    "; the AArch64 LDRB/ADR/ADD/BR chain uses a selector guarded by an unsigned upper-bound branch."
+                )
+            );
+            source.add("evidence", evidence);
+            dataSources.add(source);
+        }
+        for (int index = 0; index < referencedDataAddresses.size(); index += 1) {
             Address address = referencedDataAddresses.get(index);
+            if (
+                recoveredAArch64 != null &&
+                recoveredAArch64.tableAddress.equals(address)
+            ) {
+                continue;
+            }
             JsonObject source = new JsonObject();
             source.addProperty("address", canonicalAddress(address));
             source.addProperty(
@@ -1286,19 +1289,39 @@ public final class ReaGhidraBridge extends HeadlessScript {
             dataSources.add(source);
         }
         result.add("data_sources", dataSources);
-        result.addProperty(
-            "data_sources_truncated",
-            loadTables.length > loadTableCount ||
-            referencedDataAddresses.size() > referencedDataCount
-        );
-
         Address[] targets = jumpTable.getCases();
         Integer[] labels = jumpTable.getLabelValues();
+        boolean labelsAligned = labels != null && labels.length == targets.length;
         JsonArray mappings = new JsonArray();
-        int mappingCount = Math.min(targets.length, MAX_NATIVE_API_MAPPINGS);
-        for (int index = 0; index < mappingCount; index += 1) {
+        if (recoveredAArch64 != null) {
+            for (int index = 0; index < recoveredAArch64.mappings.size(); index += 1) {
+                monitor.checkCancelled();
+                RecoveredAArch64Mapping recovered = recoveredAArch64.mappings.get(index);
+                JsonObject mapping = new JsonObject();
+                mapping.addProperty("case_value", recovered.caseValue);
+                String targetAddress = canonicalAddress(recovered.targetAddress);
+                mapping.addProperty("target_address", targetAddress);
+                mapping.addProperty("confidence", "high");
+                JsonArray evidence = new JsonArray();
+                evidence.add(
+                    inferenceEvidence(
+                        "jump-table",
+                        "ghidra-instruction-and-memory",
+                        "Case value " + recovered.caseValue + " indexes byte " +
+                        recovered.caseValue + " at " + canonicalAddress(recoveredAArch64.tableAddress) +
+                        "; the loaded byte selects a four-byte instruction offset from " +
+                        canonicalAddress(recoveredAArch64.branchBase) + ", reaching " + targetAddress + "."
+                    )
+                );
+                mapping.add("evidence", evidence);
+                mappings.add(mapping);
+            }
+        }
+        else {
+        for (int index = 0; index < targets.length; index += 1) {
+            monitor.checkCancelled();
             JsonObject mapping = new JsonObject();
-            if (labels == null || index >= labels.length || labels[index] == null) {
+            if (!labelsAligned || labels[index] == null) {
                 mapping.add("case_value", JsonNull.INSTANCE);
             }
             else {
@@ -1306,61 +1329,299 @@ public final class ReaGhidraBridge extends HeadlessScript {
             }
             String targetAddress = canonicalAddress(targets[index]);
             mapping.addProperty("target_address", targetAddress);
-            JsonArray dataAddresses = new JsonArray();
-            for (int sourceIndex = 0; sourceIndex < loadTableCount; sourceIndex += 1) {
-                dataAddresses.add(
-                    canonicalAddress(loadTables[sourceIndex].getAddress())
-                );
-            }
-            mapping.add("data_addresses", dataAddresses);
-            mapping.addProperty("confidence", "medium");
+            // Ghidra's recovered case-to-target relation does not identify
+            // which backing load table produced an individual case. Keep the
+            // table inventory and recovered mappings separate instead of
+            // attaching every table address to every target.
+            mapping.addProperty(
+                "confidence",
+                labelsAligned && labels[index] != null
+                    ? "high"
+                    : "medium"
+            );
             JsonArray evidence = new JsonArray();
             evidence.add(
                 inferenceEvidence(
                     "jump-table",
                     "ghidra-high-function",
-                    "Recovered target " +
-                    targetAddress +
-                    " from dispatch " +
-                    canonicalAddress(jumpTable.getSwitchAddress()) +
-                    "."
+                    labelsAligned && labels[index] != null
+                        ? "Ghidra paired case value " +
+                          labels[index] +
+                          " with target " +
+                          targetAddress +
+                          " at dispatch " +
+                          canonicalAddress(jumpTable.getSwitchAddress()) +
+                          "."
+                        : "Ghidra recovered target " +
+                          targetAddress +
+                          " at dispatch " +
+                          canonicalAddress(jumpTable.getSwitchAddress()) +
+                          ", but no aligned case value was available."
                 )
             );
             mapping.add("evidence", evidence);
             mappings.add(mapping);
         }
+        }
         result.add("mappings", mappings);
-        result.addProperty("mappings_truncated", targets.length > mappingCount);
-
         JsonArray limitations = new JsonArray();
         if (loadTables.length == 0 && referencedDataAddresses.isEmpty()) {
             limitations.add(
                 "Ghidra recovered targets but exposed no backing load-table or dispatch-block data address."
             );
         }
-        if (loadTables.length == 0 && !referencedDataAddresses.isEmpty()) {
+        if (
+            recoveredAArch64 == null &&
+            loadTables.length == 0 &&
+            !referencedDataAddresses.isEmpty()
+        ) {
             limitations.add(
                 "Load-table metadata was absent; table-level candidate ownership is inferred from typed data references in the dispatch block and its immediate control-flow predecessors, but candidates are not assigned to individual mappings."
             );
         }
-        if (labels == null || labels.length != targets.length) {
+        if (recoveredAArch64 == null && !labelsAligned) {
             limitations.add(
-                "Case labels were unavailable or incomplete; null labels are preserved."
+                "Case-label and target counts differ or labels are unavailable; all case values are left unknown because index alignment cannot be established."
             );
         }
-        if (
-            loadTables.length > loadTableCount ||
-            referencedDataAddresses.size() > referencedDataCount ||
-            targets.length > mappingCount
-        ) {
+        if (targets.length == 0) {
             limitations.add(
-                "Native API jump-table observations reached REA's bounded output limits."
+                "Ghidra exposed a jump-table dispatch without recovered case targets."
             );
         }
         result.add("limitations", limitations);
         return result;
     }
 
+    private static final class RecoveredAArch64Mapping {
+        private final int caseValue;
+        private final Address targetAddress;
+
+        private RecoveredAArch64Mapping(int caseValue, Address targetAddress) {
+            this.caseValue = caseValue;
+            this.targetAddress = targetAddress;
+        }
+    }
+
+    private static final class RecoveredAArch64ByteTable {
+        private final Address tableAddress;
+        private final Address branchBase;
+        private final List<RecoveredAArch64Mapping> mappings;
+
+        private RecoveredAArch64ByteTable(
+            Address tableAddress,
+            Address branchBase,
+            List<RecoveredAArch64Mapping> mappings
+        ) {
+            this.tableAddress = tableAddress;
+            this.branchBase = branchBase;
+            this.mappings = mappings;
+        }
+    }
+
+    /**
+     * Recover only the directly verified AArch64 byte-indexed relative branch
+     * table form. Other instruction sequences keep their case labels unknown.
+     */
+    private RecoveredAArch64ByteTable recoverAArch64ByteTable(
+        JumpTable jumpTable
+    ) throws Exception {
+        if (!currentProgram.getLanguageID().getIdAsString().startsWith("AARCH64:")) {
+            return null;
+        }
+        Function function = containingFunction(jumpTable.getSwitchAddress());
+        if (function == null) return null;
+
+        List<Instruction> instructions = new ArrayList<>();
+        InstructionIterator iterator = currentProgram.getListing().getInstructions(
+            function.getBody(), true
+        );
+        while (iterator.hasNext()) {
+            monitor.checkCancelled();
+            Instruction instruction = iterator.next();
+            instructions.add(instruction);
+            if (instruction.getAddress().equals(jumpTable.getSwitchAddress())) break;
+        }
+        int branchIndex = instructions.size() - 1;
+        if (branchIndex < 1 ||
+            !instructions.get(branchIndex).getMnemonicString().equalsIgnoreCase("BR")) {
+            return null;
+        }
+
+        Address[] recoveredTargets = jumpTable.getCases();
+        Set<String> recoveredTargetSet = new HashSet<>();
+        for (Address target : recoveredTargets) recoveredTargetSet.add(canonicalAddress(target));
+        List<Address> dataAddresses = dispatchPathDataReferences(jumpTable);
+        if (dataAddresses.isEmpty()) return null;
+
+        for (int loadIndex = 0; loadIndex < branchIndex; loadIndex += 1) {
+            Instruction load = instructions.get(loadIndex);
+            if (!load.getMnemonicString().equalsIgnoreCase("LDRB")) continue;
+            String loadOperands = operands(load);
+            java.util.regex.Matcher loadMatcher = java.util.regex.Pattern
+                .compile("(?i)^[wx]\\d+,\\s*\\[([wx]\\d+),\\s*([wx]\\d+)\\]$")
+                .matcher(loadOperands);
+            if (!loadMatcher.matches()) continue;
+            String loadedRegister = normalizedRegister(loadOperands.substring(0, loadOperands.indexOf(',')));
+            String tableBaseRegister = normalizedRegister(loadMatcher.group(1));
+            String indexRegister = normalizedRegister(loadMatcher.group(2));
+
+            Address tableAddress = null;
+            for (Address candidate : dataAddresses) {
+                if (currentProgram.getMemory().contains(candidate)) {
+                    tableAddress = candidate;
+                    break;
+                }
+            }
+            if (tableAddress == null) continue;
+
+            Address resolvedTableAddress = null;
+            for (int index = 0; index < loadIndex; index += 1) {
+                Instruction instruction = instructions.get(index);
+                String mnemonic = instruction.getMnemonicString().toUpperCase(Locale.ROOT);
+                String text = operands(instruction);
+                if (mnemonic.equals("ADRP") &&
+                    text.matches("(?i)^[wx]\\d+,\\s*0x[0-9a-f]+$")) {
+                    String[] parts = text.split(",");
+                    if (normalizedRegister(parts[0]).equals(tableBaseRegister)) {
+                        resolvedTableAddress = addressFromOperand(parts[1]);
+                    }
+                }
+                else if (mnemonic.equals("ADD") && resolvedTableAddress != null &&
+                    text.matches("(?i)^[wx]\\d+,\\s*[wx]\\d+,\\s*#?(?:0x[0-9a-f]+|[0-9]+)$")) {
+                    String[] parts = text.split(",");
+                    if (normalizedRegister(parts[0]).equals(tableBaseRegister) &&
+                        normalizedRegister(parts[1]).equals(tableBaseRegister)) {
+                        resolvedTableAddress = resolvedTableAddress.add(parseInteger(parts[2].trim().replaceFirst("^#", "")));
+                    }
+                }
+            }
+            if (!tableAddress.equals(resolvedTableAddress)) continue;
+
+            Address branchBase = null;
+            boolean addressChain = false;
+            for (int index = 0; index < branchIndex; index += 1) {
+                Instruction instruction = instructions.get(index);
+                String mnemonic = instruction.getMnemonicString().toUpperCase(Locale.ROOT);
+                String text = operands(instruction);
+                if (index < loadIndex && mnemonic.equals("ADR") && text.matches("(?i)^[wx]\\d+,\\s*0x[0-9a-f]+$")) {
+                    int comma = text.indexOf(',');
+                    String destination = normalizedRegister(text.substring(0, comma));
+                    if (destination.equals(tableBaseRegister)) continue;
+                    branchBase = addressFromOperand(text.substring(comma + 1));
+                }
+                if (index > loadIndex && mnemonic.equals("ADD") && branchBase != null &&
+                    text.matches("(?i)^[wx]\\d+,\\s*[wx]\\d+,\\s*[wx]\\d+,\\s*LSL\\s*#(?:0x)?2$")) {
+                    String[] parts = text.split(",");
+                    String destination = normalizedRegister(parts[0]);
+                    String base = normalizedRegister(parts[1]);
+                    String offset = normalizedRegister(parts[2]);
+                    if (destination.equals(base) &&
+                        base.equals(normalizedRegister(operands(instructions.get(branchIndex)))) &&
+                        offset.equals(loadedRegister)) {
+                        addressChain = true;
+                    }
+                }
+            }
+            if (!addressChain || branchBase == null) continue;
+
+            int entryCount = -1;
+            Address defaultTarget = null;
+            for (int compareIndex = 0; compareIndex < loadIndex; compareIndex += 1) {
+                Instruction compare = instructions.get(compareIndex);
+                if (!compare.getMnemonicString().equalsIgnoreCase("CMP")) continue;
+                java.util.regex.Matcher compareMatcher = java.util.regex.Pattern
+                    .compile("(?i)^([wx]\\d+),\\s*#?(0x[0-9a-f]+|[0-9]+)$")
+                    .matcher(operands(compare));
+                if (!compareMatcher.matches()) continue;
+                String comparedRegister = normalizedRegister(compareMatcher.group(1));
+                long upperBound = parseInteger(compareMatcher.group(2));
+                if (upperBound < 0 || upperBound >= 4096) continue;
+                for (int guardIndex = compareIndex + 1; guardIndex < loadIndex; guardIndex += 1) {
+                    Instruction guard = instructions.get(guardIndex);
+                    String mnemonic = guard.getMnemonicString().toUpperCase(Locale.ROOT);
+                    if (!mnemonic.equals("B.HI")) continue;
+                    Address[] flows = guard.getFlows();
+                    if (flows.length != 1 || !recoveredTargetSet.contains(canonicalAddress(flows[0]))) continue;
+                    boolean selectorFeedsTable = indexRegister.equals(comparedRegister);
+                    boolean supportedSequence = true;
+                    for (int sequenceIndex = compareIndex + 1; sequenceIndex < loadIndex; sequenceIndex += 1) {
+                        String sequenceMnemonic = instructions.get(sequenceIndex)
+                            .getMnemonicString().toUpperCase(Locale.ROOT);
+                        if (!Set.of("B.HI", "MOV", "ADRP", "ADD", "ADR").contains(sequenceMnemonic)) {
+                            supportedSequence = false;
+                            break;
+                        }
+                    }
+                    for (int moveIndex = compareIndex + 1; moveIndex < loadIndex && !selectorFeedsTable; moveIndex += 1) {
+                        Instruction move = instructions.get(moveIndex);
+                        if (!move.getMnemonicString().equalsIgnoreCase("MOV")) continue;
+                        String[] moveParts = operands(move).split(",");
+                        if (moveParts.length == 2 &&
+                            normalizedRegister(moveParts[0]).equals(indexRegister) &&
+                            normalizedRegister(moveParts[1]).equals(comparedRegister)) {
+                            selectorFeedsTable = true;
+                        }
+                    }
+                    if (selectorFeedsTable && supportedSequence) {
+                        entryCount = (int) upperBound + 1;
+                        defaultTarget = flows[0];
+                        break;
+                    }
+                }
+                if (entryCount > 0) break;
+            }
+            if (entryCount <= 0 || entryCount > 4096 || defaultTarget == null) continue;
+
+            List<RecoveredAArch64Mapping> mappings = new ArrayList<>();
+            Set<String> mappedTargets = new HashSet<>();
+            boolean valid = true;
+            for (int caseValue = 0; caseValue < entryCount; caseValue += 1) {
+                int encodedOffset = currentProgram.getMemory().getByte(tableAddress.add(caseValue)) & 0xff;
+                Address target = branchBase.add((long) encodedOffset * 4L);
+                String canonicalTarget = canonicalAddress(target);
+                if (!recoveredTargetSet.contains(canonicalTarget)) {
+                    valid = false;
+                    break;
+                }
+                mappedTargets.add(canonicalTarget);
+                mappings.add(new RecoveredAArch64Mapping(caseValue, target));
+            }
+            if (!valid || mappedTargets.contains(canonicalAddress(defaultTarget))) continue;
+            Set<String> accountedTargets = new HashSet<>(mappedTargets);
+            accountedTargets.add(canonicalAddress(defaultTarget));
+            if (!accountedTargets.equals(recoveredTargetSet)) continue;
+            return new RecoveredAArch64ByteTable(tableAddress, branchBase, List.copyOf(mappings));
+        }
+        return null;
+    }
+
+    private static String operands(Instruction instruction) {
+        List<String> values = new ArrayList<>();
+        for (int index = 0; index < instruction.getNumOperands(); index += 1) {
+            values.add(instruction.getDefaultOperandRepresentation(index));
+        }
+        return String.join(", ", values);
+    }
+
+    private static String normalizedRegister(String value) {
+        String register = value.trim().toLowerCase(Locale.ROOT);
+        return register.matches("[wx]\\d+") ? "r" + register.substring(1) : register;
+    }
+
+    private static long parseInteger(String value) {
+        String number = value.toLowerCase(Locale.ROOT);
+        return number.startsWith("0x")
+            ? Long.parseUnsignedLong(number.substring(2), 16)
+            : Long.parseLong(number);
+    }
+
+    private Address addressFromOperand(String value) {
+        String hex = value.trim().replaceFirst("(?i)^0x", "");
+        return currentProgram.getAddressFactory().getDefaultAddressSpace()
+            .getAddress(Long.parseUnsignedLong(hex, 16));
+    }
+
     private List<Address> dispatchPathDataReferences(JumpTable jumpTable)
         throws Exception {
         BasicBlockModel model = new BasicBlockModel(currentProgram, false);
@@ -1443,22 +1704,16 @@ public final class ReaGhidraBridge extends HeadlessScript {
         }
         DecompileResults results = decompiler.decompileFunction(
             function,
-            DECOMPILE_TIMEOUT_SECONDS,
+            0,
             monitor
         );
-        if (results.isTimedOut()) {
-            throw new RequestFailure(
-                "decompile_timeout",
-                "Ghidra decompilation reached its 30-second deadline"
-            );
-        }
         if (results.isCancelled()) {
             throw new RequestFailure("decompile_cancelled", "Ghidra decompilation was cancelled");
         }
         if (!results.decompileCompleted()) {
             throw new RequestFailure(
                 "decompile_failed",
-                "Ghidra decompilation failed: " + boundedMessage(results.getErrorMessage())
+                "Ghidra decompilation failed: " + diagnosticMessage(results.getErrorMessage())
             );
         }
         return results;
@@ -1540,9 +1795,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
             reference.getOperandIndex() + "\u0000" +
             reference.isPrimary();
         observed.putIfAbsent(key, reference);
-        if (observed.size() > MAX_FUNCTION_ITEMS) {
-            throw functionLimit("Reference set exceeds the 100000-item limit");
-        }
     }
 
     private JsonArray referenceEdges(List<Reference> references) {
@@ -1623,9 +1875,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
 
     private static JsonArray functionLocals(Function function) {
         Variable[] variables = function.getLocalVariables();
-        if (variables.length > MAX_FUNCTION_ITEMS) {
-            throw functionLimit("Local-variable set exceeds the 100000-item limit");
-        }
         List<Variable> ordered = new ArrayList<>(List.of(variables));
         ordered.sort(
             Comparator.comparing(Variable::getName)
@@ -1646,9 +1895,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
     }
 
     private JsonArray procedureIdentities(Set<Function> functions) {
-        if (functions.size() > MAX_FUNCTION_ITEMS) {
-            throw functionLimit("Resolved call set exceeds the 100000-item limit");
-        }
         List<Function> ordered = new ArrayList<>(functions);
         ordered.sort(Comparator.comparing(Function::getEntryPoint));
         JsonArray result = new JsonArray();
@@ -1664,9 +1910,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
         List<CodeBlock> result = new ArrayList<>();
         while (iterator.hasNext()) {
             monitor.checkCancelled();
-            if (result.size() >= MAX_FUNCTION_ITEMS) {
-                throw functionLimit("Basic-block set exceeds the 100000-item limit");
-            }
             result.add(iterator.next());
         }
         result.sort(Comparator.comparing(CodeBlock::getFirstStartAddress));
@@ -1723,10 +1966,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
                 String key = canonicalAddress(instruction.getAddress()) + "\u0000" +
                     kind + "\u0000" + type.name() + "\u0000" + text;
                 observed.put(key, item);
-                if (observed.size() > MAX_FUNCTION_ITEMS) {
-                    throw functionLimit("Comment set exceeds the 100000-item limit");
-                }
-            }
+                    }
         }
         JsonArray result = new JsonArray();
         observed.values().forEach(result::add);
@@ -1753,10 +1993,7 @@ public final class ReaGhidraBridge extends HeadlessScript {
             String key = canonicalAddress(data.getAddress()) + "\u0000" + value + "\u0000" +
                 canonicalAddress(reference.getFromAddress());
             observed.put(key, item);
-            if (observed.size() > MAX_FUNCTION_ITEMS) {
-                throw functionLimit("Referenced-string set exceeds the 100000-item limit");
             }
-        }
         JsonArray result = new JsonArray();
         observed.values().forEach(result::add);
         return result;
@@ -1778,96 +2015,12 @@ public final class ReaGhidraBridge extends HeadlessScript {
             String key = canonicalAddress(reference.getToAddress()) + "\u0000" +
                 symbol.getName(true) + "\u0000" + canonicalAddress(reference.getFromAddress());
             observed.put(key, item);
-            if (observed.size() > MAX_FUNCTION_ITEMS) {
-                throw functionLimit("Referenced-name set exceeds the 100000-item limit");
             }
-        }
         JsonArray result = new JsonArray();
         observed.values().forEach(result::add);
         return result;
     }
 
-    private static JsonObject pseudocodePage(String value, int offset, int limit) {
-        int total = value.codePointCount(0, value.length());
-        int start = Math.min(offset, total);
-        int returned = Math.min(limit, total - start);
-        int startIndex = value.offsetByCodePoints(0, start);
-        int endIndex = value.offsetByCodePoints(startIndex, returned);
-        int next = start + returned;
-        JsonObject result = new JsonObject();
-        result.addProperty("text", value.substring(startIndex, endIndex));
-        result.addProperty("total_chars", total);
-        result.addProperty("returned_chars", returned);
-        result.addProperty("truncated", next < total);
-        if (next < total) {
-            result.addProperty("next_offset", next);
-        }
-        else {
-            result.add("next_offset", JsonNull.INSTANCE);
-        }
-        return result;
-    }
-
-    private static JsonObject bounded(
-            JsonArray values,
-            int offset,
-            int limit,
-            boolean complete) {
-        int start = Math.min(offset, values.size());
-        int end = Math.min(values.size(), start + limit);
-        JsonArray items = new JsonArray();
-        for (int index = start; index < end; index += 1) {
-            items.add(values.get(index).deepCopy());
-        }
-        boolean hasMore = end < values.size();
-        JsonObject result = new JsonObject();
-        result.add("items", items);
-        if (complete) {
-            result.addProperty("total", values.size());
-        }
-        else {
-            result.add("total", JsonNull.INSTANCE);
-        }
-        result.addProperty("returned", items.size());
-        result.addProperty("truncated", !complete || hasMore);
-        if (complete && hasMore) {
-            result.addProperty("next_offset", end);
-        }
-        else {
-            result.add("next_offset", JsonNull.INSTANCE);
-        }
-        return result;
-    }
-
-    private static JsonObject requireCollectionOffsets(JsonObject params) {
-        JsonElement value = params.get("collection_offset");
-        if (value == null || !value.isJsonObject()) {
-            throw new RequestFailure("invalid_request", "collection_offset must be an object");
-        }
-        JsonObject result = value.getAsJsonObject();
-        requireKeys(
-            result,
-            Set.of(
-                "comments",
-                "callers",
-                "callees",
-                "incoming_references",
-                "outgoing_references",
-                "referenced_strings",
-                "referenced_names",
-                "basic_blocks"
-            )
-        );
-        for (String name : result.keySet()) {
-            requireBoundedInteger(result, name, 0, Integer.MAX_VALUE);
-        }
-        return result;
-    }
-
-    private static int collectionOffset(JsonObject offsets, String name) {
-        return requireBoundedInteger(offsets, name, 0, Integer.MAX_VALUE);
-    }
-
     private static String exclusiveAddress(Address inclusive) {
         Address next = inclusive.next();
         if (next != null && next.getAddressSpace().equals(inclusive.getAddressSpace())) {
@@ -1877,58 +2030,28 @@ public final class ReaGhidraBridge extends HeadlessScript {
         return canonicalOffset(inclusive.getAddressSpace(), offset.add(BigInteger.ONE));
     }
 
-    private static String boundedMessage(String value) {
+    private static String diagnosticMessage(String value) {
         if (value == null || value.isBlank()) {
             return "native decompiler returned no detail";
         }
-        return truncate(value.replaceAll("[\\r\\n]+", " "), 512).value;
-    }
-
-    private static RequestFailure functionLimit(String message) {
-        return new RequestFailure("limit_exceeded", message);
+        return value.replaceAll("[\\r\\n]+", " ");
     }
 
-    private JsonObject page(
-            List<InventoryItem> inventory,
-            int offset,
-            int limit,
-            String factsName) {
-        int start = Math.min(offset, inventory.size());
-        int end = Math.min(inventory.size(), start + limit);
-        JsonArray items = new JsonArray();
-        for (int index = start; index < end; index += 1) {
-            items.add(resultItem(inventory.get(index), factsName, MAX_LIST_VALUE_CODE_POINTS));
-        }
-        return pageResult(items, offset, limit, inventory.size());
-    }
-
-    private static JsonObject pageResult(JsonArray items, int offset, int limit, int total) {
-        int next = offset + items.size();
-        boolean hasMore = next < total;
-        JsonObject result = new JsonObject();
-        result.add("items", items);
-        result.addProperty("offset", offset);
-        result.addProperty("limit", limit);
-        result.addProperty("total", total);
-        if (hasMore) {
-            result.addProperty("next_offset", next);
-        }
-        else {
-            result.add("next_offset", JsonNull.INSTANCE);
+    private JsonArray inventory(
+        List<InventoryItem> inventory,
+        String factsName) throws Exception {
+        JsonArray result = new JsonArray();
+        for (InventoryItem item : inventory) {
+            monitor.checkCancelled();
+            result.add(resultItem(item, factsName));
         }
-        result.addProperty("has_more", hasMore);
         return result;
     }
 
-    private static JsonObject resultItem(
-            InventoryItem item,
-            String factsName,
-            int maximumCodePoints) {
-        TruncatedValue truncated = truncate(item.value, maximumCodePoints);
+    private static JsonObject resultItem(InventoryItem item, String factsName) {
         JsonObject result = new JsonObject();
         result.addProperty("address", canonicalAddress(item.address));
-        result.addProperty("value", truncated.value);
-        result.addProperty("value_truncated", truncated.truncated);
+        result.addProperty("value", item.value);
         if (factsName != null) {
             result.add(factsName, item.facts.deepCopy());
         }
@@ -2088,55 +2211,17 @@ public final class ReaGhidraBridge extends HeadlessScript {
         return source.name().toLowerCase(Locale.ROOT);
     }
 
-    private static void addBounded(List<InventoryItem> destination, InventoryItem item) {
-        if (destination.size() >= MAX_INVENTORY_ITEMS) {
-            throw inventoryLimit();
-        }
-        destination.add(item);
-    }
-
-    private static RequestFailure inventoryLimit() {
-        return new RequestFailure(
-            "limit_exceeded",
-            "Ghidra inventory exceeds the 1000000-item safety limit"
-        );
-    }
-
-    private static TruncatedValue truncate(String value, int maximumCodePoints) {
-        int codePoints = value.codePointCount(0, value.length());
-        if (codePoints <= maximumCodePoints) {
-            return new TruncatedValue(value, false);
-        }
-        int end = value.offsetByCodePoints(0, maximumCodePoints);
-        return new TruncatedValue(value.substring(0, end), true);
-    }
-
     private static ValueMatcher literalMatcher(String pattern, boolean caseSensitive) {
         String needle = caseSensitive ? pattern : pattern.toLowerCase(Locale.ROOT);
-        return new ValueMatcher() {
-            private long remaining = MAX_LITERAL_SEARCH_WORK_UNITS;
-
-            @Override
-            public boolean matches(String value) {
-                long required = (long) Math.max(value.length(), 1) + needle.length();
-                if (required > remaining) {
-                    throw new RequestFailure(
-                        "limit_exceeded",
-                        "Literal search exceeds the 1000000-unit work budget"
-                    );
-                }
-                remaining -= required;
-                String candidate = caseSensitive ? value : value.toLowerCase(Locale.ROOT);
-                return candidate.contains(needle);
-            }
+        return value -> {
+            String candidate = caseSensitive ? value : value.toLowerCase(Locale.ROOT);
+            return candidate.contains(needle);
         };
     }
 
     private static ValueMatcher regexMatcher(String expression, boolean caseSensitive) {
-        RegexMetrics metrics;
         Pattern pattern;
         try {
-            metrics = new BoundedRegexParser(expression).parse();
             pattern = Pattern.compile(
                 expression,
                 caseSensitive ? 0 : Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE
@@ -2145,43 +2230,17 @@ public final class ReaGhidraBridge extends HeadlessScript {
         catch (PatternSyntaxException exception) {
             throw new RequestFailure("invalid_request", "Invalid regex pattern");
         }
-        long workPerCharacter = metrics.paths * Math.max(metrics.steps, 1);
-        return new ValueMatcher() {
-            private long remaining = MAX_REGEX_SEARCH_WORK_UNITS;
-
-            @Override
-            public boolean matches(String value) {
-                if (value.length() > MAX_REGEX_CANDIDATE_CHARACTERS) {
-                    throw new RequestFailure(
-                        "limit_exceeded",
-                        "Regex candidate exceeds the 4096-character safety limit"
-                    );
-                }
-                long required = workPerCharacter * Math.max(value.length(), 1);
-                if (required > remaining) {
-                    throw new RequestFailure(
-                        "limit_exceeded",
-                        "Regex search exceeds the 1000000-unit work budget"
-                    );
-                }
-                remaining -= required;
-                return pattern.matcher(value).find();
-            }
-        };
+        return value -> pattern.matcher(value).find();
     }
 
     private static SessionDescriptor readDescriptor(Path path) throws IOException {
-        if (!Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS) ||
-            Files.size(path) > MAX_DESCRIPTOR_BYTES) {
+        if (!Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS)) {
             throw new IllegalArgumentException("REA session descriptor is invalid");
         }
         JsonObject object = requireObject(
             JsonParser.parseString(Files.readString(path, StandardCharsets.UTF_8)),
             DESCRIPTOR_KEYS
         );
-        if (requireInteger(object, "schema_version") != 2) {
-            throw new IllegalArgumentException("REA session descriptor version is invalid");
-        }
         return new SessionDescriptor(
             requireString(object, "transport"),
             requireString(object, "endpoint_path"),
@@ -2312,25 +2371,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
         );
     }
 
-    private static String readBoundedLine(Reader reader, int maximumCharacters) throws IOException {
-        StringBuilder line = new StringBuilder();
-        while (true) {
-            int character = reader.read();
-            if (character < 0) {
-                return line.isEmpty() ? null : line.toString();
-            }
-            if (character == '\n') {
-                return line.toString();
-            }
-            if (character != '\r') {
-                if (line.length() >= maximumCharacters) {
-                    throw new IOException("Bridge request exceeded the maximum line size");
-                }
-                line.append((char) character);
-            }
-        }
-    }
-
     private static void writeSuccess(BufferedWriter writer, int id, JsonElement result)
             throws IOException {
         JsonObject response = new JsonObject();
@@ -2357,17 +2397,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
 
     private static void writeResponse(BufferedWriter writer, JsonObject response) throws IOException {
         String encoded = GSON.toJson(response);
-        if (encoded.getBytes(StandardCharsets.UTF_8).length > MAX_RESPONSE_BYTES) {
-            int id = response.get("id").getAsInt();
-            JsonObject error = new JsonObject();
-            error.addProperty("code", "output_limit");
-            error.addProperty("message", "Ghidra response exceeds the 1 MiB wire limit");
-            JsonObject bounded = new JsonObject();
-            bounded.addProperty("id", id);
-            bounded.addProperty("ok", false);
-            bounded.add("error", error);
-            encoded = GSON.toJson(bounded);
-        }
         writer.write(encoded);
         writer.newLine();
         writer.flush();
@@ -2396,7 +2425,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
     private record InventoryItem(Address address, String value, JsonObject facts) {}
     private record FunctionEntry(Function function, InventoryItem item) {}
     private record InstructionScan(List<Instruction> instructions, boolean truncated) {}
-    private record TruncatedValue(String value, boolean truncated) {}
     private record SessionDescriptor(
         String transport,
         String endpointPath,
@@ -2407,7 +2435,6 @@ public final class ReaGhidraBridge extends HeadlessScript {
         String profileDigest
     ) {}
     private record Request(int id, String method, JsonObject params) {}
-    private record RegexMetrics(long paths, long steps, boolean containsRepeat) {}
 
     private static final class RequestFailure extends RuntimeException {
         private final String code;
@@ -2418,263 +2445,4 @@ public final class ReaGhidraBridge extends HeadlessScript {
         }
     }
 
-    private static final class BoundedRegexParser {
-        private final String expression;
-        private int index;
-
-        BoundedRegexParser(String expression) {
-            this.expression = expression;
-        }
-
-        RegexMetrics parse() {
-            RegexMetrics result = parseExpression(false);
-            if (index != expression.length()) {
-                throw invalidRegex();
-            }
-            return result;
-        }
-
-        private RegexMetrics parseExpression(boolean grouped) {
-            RegexMetrics result = parseSequence(grouped);
-            while (peek('|')) {
-                index += 1;
-                RegexMetrics branch = parseSequence(grouped);
-                result = new RegexMetrics(
-                    checkedPaths(result.paths, branch.paths, false),
-                    Math.max(result.steps, branch.steps),
-                    result.containsRepeat || branch.containsRepeat
-                );
-            }
-            return result;
-        }
-
-        private RegexMetrics parseSequence(boolean grouped) {
-            RegexMetrics result = new RegexMetrics(1, 0, false);
-            while (index < expression.length() && !peek('|') && !(grouped && peek(')'))) {
-                RegexMetrics item = parseAtom();
-                result = new RegexMetrics(
-                    checkedPaths(result.paths, item.paths, true),
-                    result.steps + item.steps,
-                    result.containsRepeat || item.containsRepeat
-                );
-            }
-            return result;
-        }
-
-        private RegexMetrics parseAtom() {
-            if (index >= expression.length()) {
-                throw invalidRegex();
-            }
-            char item = expression.charAt(index++);
-            RegexMetrics atom;
-            if (item == '(') {
-                if (peek('?')) {
-                    if (index + 1 >= expression.length() || expression.charAt(index + 1) != ':') {
-                        throw new RequestFailure(
-                            "invalid_request",
-                            "Regex lookarounds and backreferences are not supported"
-                        );
-                    }
-                    index += 2;
-                }
-                atom = parseExpression(true);
-                if (!peek(')')) {
-                    throw invalidRegex();
-                }
-                index += 1;
-            }
-            else if (item == '[') {
-                consumeCharacterClass();
-                atom = leaf();
-            }
-            else if (item == '\\') {
-                consumeEscape();
-                atom = leaf();
-            }
-            else if (item == '*' || item == '+') {
-                throw unboundedRepeat();
-            }
-            else if (item == '?' || item == '{' || item == '}' || item == ')') {
-                throw invalidRegex();
-            }
-            else {
-                atom = leaf();
-            }
-            if (index >= expression.length()) {
-                return atom;
-            }
-            if (peek('*') || peek('+')) {
-                throw unboundedRepeat();
-            }
-            int minimum;
-            int maximum;
-            if (peek('?')) {
-                index += 1;
-                minimum = 0;
-                maximum = 1;
-            }
-            else if (peek('{')) {
-                int[] bounds = consumeBounds();
-                minimum = bounds[0];
-                maximum = bounds[1];
-            }
-            else {
-                return atom;
-            }
-            if (atom.containsRepeat) {
-                throw new RequestFailure(
-                    "invalid_request",
-                    "Nested regex repetitions are not supported"
-                );
-            }
-            if (maximum > 1_000) {
-                throw unboundedRepeat();
-            }
-            return new RegexMetrics(
-                repeatPaths(atom.paths, minimum, maximum),
-                maximum * atom.steps,
-                true
-            );
-        }
-
-        private void consumeCharacterClass() {
-            boolean escaped = false;
-            boolean hasContent = false;
-            while (index < expression.length()) {
-                char item = expression.charAt(index++);
-                if (escaped) {
-                    escaped = false;
-                    hasContent = true;
-                }
-                else if (item == '\\') {
-                    escaped = true;
-                }
-                else if (item == ']' && hasContent) {
-                    return;
-                }
-                else {
-                    hasContent = true;
-                }
-            }
-            throw invalidRegex();
-        }
-
-        private void consumeEscape() {
-            if (index >= expression.length()) {
-                throw invalidRegex();
-            }
-            char escaped = expression.charAt(index++);
-            if (Character.isDigit(escaped) || escaped == 'k') {
-                throw new RequestFailure(
-                    "invalid_request",
-                    "Regex lookarounds and backreferences are not supported"
-                );
-            }
-            if (escaped == 'Q' || escaped == 'E' || escaped == 'p' || escaped == 'P') {
-                throw new RequestFailure(
-                    "invalid_request",
-                    "Regex operation is not supported by the bounded matcher"
-                );
-            }
-            if (escaped == 'x') {
-                consumeHexDigits(2);
-            }
-            else if (escaped == 'u') {
-                consumeHexDigits(4);
-            }
-        }
-
-        private void consumeHexDigits(int count) {
-            if (index + count > expression.length()) {
-                throw invalidRegex();
-            }
-            for (int current = 0; current < count; current += 1) {
-                if (Character.digit(expression.charAt(index + current), 16) < 0) {
-                    throw invalidRegex();
-                }
-            }
-            index += count;
-        }
-
-        private int[] consumeBounds() {
-            index += 1;
-            int minimum = consumeDecimal();
-            int maximum = minimum;
-            if (peek(',')) {
-                index += 1;
-                if (peek('}')) {
-                    throw unboundedRepeat();
-                }
-                maximum = consumeDecimal();
-            }
-            if (!peek('}') || minimum > maximum) {
-                throw invalidRegex();
-            }
-            index += 1;
-            return new int[] { minimum, maximum };
-        }
-
-        private int consumeDecimal() {
-            int start = index;
-            long value = 0;
-            while (index < expression.length() && Character.isDigit(expression.charAt(index))) {
-                value = value * 10 + Character.digit(expression.charAt(index), 10);
-                if (value > Integer.MAX_VALUE) {
-                    throw unboundedRepeat();
-                }
-                index += 1;
-            }
-            if (index == start) {
-                throw invalidRegex();
-            }
-            return (int) value;
-        }
-
-        private boolean peek(char expected) {
-            return index < expression.length() && expression.charAt(index) == expected;
-        }
-
-        private static RegexMetrics leaf() {
-            return new RegexMetrics(1, 1, false);
-        }
-
-        private static long repeatPaths(long childPaths, int minimum, int maximum) {
-            long result = 0;
-            long repeated = 1;
-            for (int count = 0; count <= maximum; count += 1) {
-                if (count >= minimum) {
-                    result = checkedPaths(result, repeated, false);
-                }
-                if (count < maximum) {
-                    repeated = checkedPaths(repeated, childPaths, true);
-                }
-            }
-            return result;
-        }
-
-        private static long checkedPaths(long left, long right, boolean multiply) {
-            boolean exceeded = multiply
-                ? right != 0 && left > MAX_REGEX_BACKTRACKING_PATHS / right
-                : left > MAX_REGEX_BACKTRACKING_PATHS - right;
-            long result = multiply ? left * right : left + right;
-            if (exceeded || result > MAX_REGEX_BACKTRACKING_PATHS) {
-                throw new RequestFailure(
-                    "invalid_request",
-                    "Regex exceeds the 10000-path backtracking budget"
-                );
-            }
-            return result;
-        }
-
-        private static RequestFailure unboundedRepeat() {
-            return new RequestFailure(
-                "invalid_request",
-                "Unbounded or excessive regex repetitions are not supported"
-            );
-        }
-
-        private static RequestFailure invalidRegex() {
-            return new RequestFailure("invalid_request", "Invalid regex pattern");
-        }
-    }
 }