@futpib/parser 1.0.3 → 1.0.6

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@futpib/parser",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "main": "build/index.js",
+  "types": "build/index.d.ts",
   "license": "GPL-3.0-only",
   "type": "module",
   "scripts": {
     "dev": "tsc --watch",
     "build": "tsc",
+    "tsd": "tsd --files 'src/**/*.test-d.ts'",
     "test": "c8 ava",
     "prepack": "yarn build"
   },
@@ -21,13 +23,26 @@
     "verbose": true,
     "timeout": "60s"
   },
+  "tsd": {
+    "directory": "src",
+    "compilerOptions": {
+      "lib": [
+        "ES2022",
+        "DOM",
+        "DOM.AsyncIterable"
+      ]
+    }
+  },
   "devDependencies": {
     "@ava/typescript": "^6.0.0",
     "@fast-check/ava": "^2.0.2",
+    "@futpib/fetch-cid": "^1.0.2",
+    "@gruhn/regex-utils": "^2.7.3",
+    "@types/estree": "^1.0.8",
     "@types/invariant": "^2.2.37",
-    "@types/node": "^24.4.0",
+    "@types/node": "^24.10.1",
     "ava": "^6.4.1",
-    "bson": "^6.10.4",
+    "bson": "^7.0.0",
     "c8": "^10.1.3",
     "coveralls": "^3.1.1",
     "env-paths": "^3.0.0",
@@ -39,13 +54,17 @@
     "leb128": "^0.0.5",
     "mutf-8": "^1.2.2",
     "p-memoize": "^8.0.0",
+    "s-expression": "^3.1.1",
     "tempy": "^3.1.0",
-    "type-fest": "^5.0.0",
-    "typescript": "^5.9.2",
-    "xo": "^1.2.2"
+    "tsd": "^0.33.0",
+    "type-fest": "^5.2.0",
+    "typescript": "^5.9.3",
+    "xo": "^1.2.3"
   },
   "packageManager": "yarn@4.9.4",
   "dependencies": {
+    "acorn": "^8.15.0",
+    "astring": "^1.9.0",
     "fp-ts": "^2.16.11",
     "mem": "^10.0.0",
     "monocle-ts": "^2.3.13",

package/src/androidPackageParser.ts

@@ -26,6 +26,7 @@ import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createExactElementParser } from './exactElementParser.js';
+import { createObjectParser } from './objectParser.js';
 import { createParserConsumedSequenceParser } from './parserConsumedSequenceParser.js';
 import { createDebugLogInputParser } from './debugLogInputParser.js';
 import { createDebugLogParser } from './debugLogParser.js';
@@ -86,13 +87,11 @@ type AndroidPackageSigningBlockSignatureV2Pair = {
 };
 
 const createAndroidPackageSigningBlockSignatureV2PairInnerParser = (length: number): Parser<AndroidPackageSigningBlockSignatureV2Pair, Uint8Array> => {
-	const androidPackageSigningBlockSignatureV2PairInnerParser = promiseCompose(
-		createTupleParser([
-			createExactSequenceParser<Uint8Array>(Buffer.from('1a870971', 'hex')),
-			androidPackageSignatureV2SignersParser,
-		]),
-		([ _magic, signers = [] ]) => ({ type: 'signatureV2' as const, signers }),
-	);
+	const androidPackageSigningBlockSignatureV2PairInnerParser = createObjectParser({
+		type: 'signatureV2' as const,
+		_magic: createExactSequenceParser<Uint8Array>(Buffer.from('1a870971', 'hex')),
+		signers: androidPackageSignatureV2SignersParser,
+	});
 
 	return setParserName(androidPackageSigningBlockSignatureV2PairInnerParser, 'androidPackageSigningBlockSignatureV2PairInnerParser');
 };
@@ -102,13 +101,13 @@ type AndroidPackageSigningBlockGenericPair = {
 	pair: AndroidPackageSigningBlockPair;
 };
 
-const createAndroidPackageSigningBlockGenericPairInnerParser = (length: number): Parser<AndroidPackageSigningBlockGenericPair, Uint8Array> => promiseCompose(
-	createTupleParser([
-		uint32LEParser,
-		createFixedLengthSequenceParser(length - 4),
-	]),
-	([ id, value ]) => ({ type: 'generic', pair: { id, value } }),
-);
+const createAndroidPackageSigningBlockGenericPairInnerParser = (length: number): Parser<AndroidPackageSigningBlockGenericPair, Uint8Array> => createObjectParser({
+	type: 'generic' as const,
+	pair: createObjectParser({
+		id: uint32LEParser,
+		value: createFixedLengthSequenceParser<Uint8Array>(length - 4),
+	}),
+});
 
 type AndroidPackageSigningBlockPairType =
 	| AndroidPackageSigningBlockZeroPaddingPair
@@ -126,7 +125,7 @@ const createAndroidPackageSigningBlockPairInnerParser = (length: number): Parser
 					length,
 				);
 			},
-			createDisjunctionParser<AndroidPackageSigningBlockPairType, Uint8Array>([
+			createDisjunctionParser([
 				createAndroidPackageSigningBlockZeroPaddingPairInnerParser(length),
 				createAndroidPackageSigningBlockSignatureV2PairInnerParser(length),
 				createAndroidPackageSigningBlockGenericPairInnerParser(length),
@@ -189,13 +188,10 @@ export const androidPackageSigningBlockParser: Parser<AndroidPackageSigningBlock
 	},
 ));
 
-const androidPackageSignatureV2DigestParser = createUint32LengthPrefixedParser<AndroidPackageSignatureV2Digest>(pairLength => promiseCompose(
-	createTupleParser([
-		uint32LEParser,
-		createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
-	]),
-	([ signatureAlgorithmId, digest ]) => ({ signatureAlgorithmId, digest }),
-));
+const androidPackageSignatureV2DigestParser = createUint32LengthPrefixedParser<AndroidPackageSignatureV2Digest>(pairLength => createObjectParser({
+	signatureAlgorithmId: uint32LEParser,
+	digest: createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
+}));
 
 const androidPackageSignatureV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2DigestParser);
 
@@ -209,13 +205,10 @@ const androidPackageSignatureV2CertificatesParser = createUint32LengthPrefixedSl
 
 setParserName(androidPackageSignatureV2CertificatesParser, 'androidPackageSignatureV2CertificatesParser');
 
-const androidPackageSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser<AndroidPackageSignatureV2AdditionalAttribute>(pairLength => promiseCompose(
-	createTupleParser([
-		uint32LEParser,
-		createFixedLengthSequenceParser(pairLength - 4),
-	]),
-	([ id, value ]) => ({ id, value }),
-));
+const androidPackageSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser<AndroidPackageSignatureV2AdditionalAttribute>(pairLength => createObjectParser({
+	id: uint32LEParser,
+	value: createFixedLengthSequenceParser<Uint8Array>(pairLength - 4),
+}));
 
 setParserName(androidPackageSignatureV2AdditionalAttributeParser, 'androidPackageSignatureV2AdditionalAttributeParser');
 
@@ -228,7 +221,7 @@ const androidPackageSignatureV2SignedDataParser = createUint32LengthPrefixedSlic
 		androidPackageSignatureV2DigestsParser,
 		androidPackageSignatureV2CertificatesParser,
 		androidPackageSignatureV2AdditionalAttributesParser,
-		createArrayParser(createExactElementParser(0)),
+		createArrayParser(createExactElementParser<Uint8Array>(0)),
 	]),
 	([
 		digests,
@@ -245,19 +238,10 @@ const androidPackageSignatureV2SignedDataParser = createUint32LengthPrefixedSlic
 
 setParserName(androidPackageSignatureV2SignedDataParser, 'androidPackageSignatureV2SignedDataParser');
 
-const androidPackageSignatureV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(
-	createTupleParser([
-		uint32LEParser,
-		createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
-	]),
-	([
-		signatureAlgorithmId,
-		signature,
-	]): AndroidPackageSignatureV2Signature => ({
-		signatureAlgorithmId,
-		signature,
-	}),
-));
+const androidPackageSignatureV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => createObjectParser({
+	signatureAlgorithmId: uint32LEParser,
+	signature: createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
+}));
 
 const androidPackageSignatureV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2SignatureParser);
 
@@ -267,22 +251,11 @@ const androidPackageSignatureV2PublicKeyParser = createUint32LengthPrefixedParse
 
 setParserName(androidPackageSignatureV2PublicKeyParser, 'androidPackageSignatureV2PublicKeyParser');
 
-const androidPackageSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(
-	createTupleParser([
-		androidPackageSignatureV2SignedDataParser,
-		androidPackageSignatureV2SignaturesParser,
-		androidPackageSignatureV2PublicKeyParser,
-	]),
-	([
-		signedData,
-		signatures = [],
-		publicKey,
-	]): AndroidPackageSignatureV2Signer => ({
-		signedData,
-		signatures,
-		publicKey,
-	}),
-));
+const androidPackageSignatureV2SignerParser: Parser<AndroidPackageSignatureV2Signer, Uint8Array> = createUint32LengthPrefixedSliceBoundedParser(createObjectParser({
+	signedData: androidPackageSignatureV2SignedDataParser,
+	signatures: androidPackageSignatureV2SignaturesParser,
+	publicKey: androidPackageSignatureV2PublicKeyParser,
+}));
 
 setParserName(androidPackageSignatureV2SignerParser, 'androidPackageSignatureV2SignerParser');
 
@@ -350,7 +323,7 @@ export const androidPackageSignableSectionsParser: Parser<AndroidPackageSignable
 			createOptionalParser(zipArchiveDecryptionHeaderParser),
 			createOptionalParser(zipArchiveExtraDataRecordParser),
 		])),
-		createArrayParser(createExactElementParser(0)),
+		createArrayParser(createExactElementParser<Uint8Array>(0)),
 		createOptionalParser(createParserConsumedSequenceParser(androidPackageSigningBlockParser)),
 		createParserConsumedSequenceParser(createTupleParser([
 			createArrayParser(zipCentralDirectoryHeaderParser),

package/src/arbitraryDalvikBytecode.ts

@@ -1,7 +1,7 @@
 import * as fc from 'fast-check';
 import {
-	type DalvikBytecode,
-	type DalvikBytecodeOperation,
+	type RawDalvikBytecode,
+	type RawDalvikBytecodeOperation,
 } from './dalvikBytecodeParser.js';
 import {
 	type IndexIntoStringIds,
@@ -9,11 +9,13 @@ import {
 	type IndexIntoMethodIds,
 	type IndexIntoFieldIds,
 	type IndexIntoPrototypeIds,
+	type CodeUnit,
 	isoIndexIntoStringIds,
 	isoIndexIntoTypeIds,
 	isoIndexIntoMethodIds,
 	isoIndexIntoFieldIds,
 	isoIndexIntoPrototypeIds,
+	isoCodeUnit,
 } from './dalvikExecutableParser/typedNumbers.js';
 
 // Arbitrary generators for typed indexes
@@ -49,13 +51,19 @@ const arbitraryShortValue = fc.integer({ min: -32768, max: 32767 }); // 16-bit s
 const arbitraryIntValue = fc.integer({ min: -2147483648, max: 2147483647 }); // 32-bit signed
 const arbitraryLongValue = fc.bigInt({ min: -9223372036854775808n, max: 9223372036854775807n }); // 64-bit signed
 
-// Arbitrary branch offsets (relative)
-const arbitraryBranchOffset8 = fc.integer({ min: -128, max: 127 });
-const arbitraryBranchOffset16 = fc.integer({ min: -32768, max: 32767 });
-const arbitraryBranchOffset32 = fc.integer({ min: -2147483648, max: 2147483647 });
+// Arbitrary branch offsets (relative) - wrapped as CodeUnit
+const arbitraryBranchOffsetCodeUnit8: fc.Arbitrary<CodeUnit> = fc
+	.integer({ min: -128, max: 127 })
+	.map(n => isoCodeUnit.wrap(n));
+const arbitraryBranchOffsetCodeUnit16: fc.Arbitrary<CodeUnit> = fc
+	.integer({ min: -32768, max: 32767 })
+	.map(n => isoCodeUnit.wrap(n));
+const arbitraryBranchOffsetCodeUnit32: fc.Arbitrary<CodeUnit> = fc
+	.integer({ min: -2147483648, max: 2147483647 })
+	.map(n => isoCodeUnit.wrap(n));
 
 // No-operation
-const arbitraryNop = fc.constant<DalvikBytecodeOperation>({
+const arbitraryNop = fc.constant<RawDalvikBytecodeOperation>({
 	operation: 'nop',
 });
 
@@ -119,7 +127,7 @@ const arbitraryMoveException = fc.record({
 });
 
 // Return operations
-const arbitraryReturnVoid = fc.constant<DalvikBytecodeOperation>({
+const arbitraryReturnVoid = fc.constant<RawDalvikBytecodeOperation>({
 	operation: 'return-void',
 });
 
@@ -265,36 +273,36 @@ const arbitraryThrow = fc.record({
 // Goto operations
 const arbitraryGoto = fc.record({
 	operation: fc.constant('goto' as const),
-	branchOffset: arbitraryBranchOffset8,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit8,
 });
 
 const arbitraryGoto16 = fc.record({
 	operation: fc.constant('goto/16' as const),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryGoto32 = fc.record({
 	operation: fc.constant('goto/32' as const),
-	branchOffset: arbitraryBranchOffset32,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit32,
 });
 
 // Switch operations
 const arbitraryPackedSwitch = fc.record({
 	operation: fc.constant('packed-switch' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset32,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit32,
 });
 
 const arbitrarySparseSwitch = fc.record({
 	operation: fc.constant('sparse-switch' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset32,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit32,
 });
 
 const arbitraryFillArrayData = fc.record({
 	operation: fc.constant('fill-array-data' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset32,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit32,
 });
 
 // Payload operations
@@ -304,7 +312,7 @@ const arbitraryPackedSwitchPayload = fc
 		fc.record({
 			operation: fc.constant('packed-switch-payload' as const),
 			value: arbitraryIntValue,
-			branchOffsets: fc.array(arbitraryBranchOffset32, { minLength: size, maxLength: size }),
+			branchOffsetsCodeUnit: fc.array(arbitraryBranchOffsetCodeUnit32, { minLength: size, maxLength: size }),
 		})
 	);
 
@@ -314,7 +322,7 @@ const arbitrarySparseSwitchPayload = fc
 		fc.record({
 			operation: fc.constant('sparse-switch-payload' as const),
 			keys: fc.array(arbitraryIntValue, { minLength: size, maxLength: size }),
-			branchOffsets: fc.array(arbitraryBranchOffset32, { minLength: size, maxLength: size }),
+			branchOffsetsCodeUnit: fc.array(arbitraryBranchOffsetCodeUnit32, { minLength: size, maxLength: size }),
 		})
 	);
 
@@ -337,74 +345,74 @@ const arbitraryFillArrayDataPayload = fc
 const arbitraryIfEqual = fc.record({
 	operation: fc.constant('if-eq' as const),
 	registers: fc.tuple(arbitraryRegister4, arbitraryRegister4).map(([a, b]) => [a, b].sort((x, y) => x - y)),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfNotEqual = fc.record({
 	operation: fc.constant('if-ne' as const),
 	registers: fc.tuple(arbitraryRegister4, arbitraryRegister4).map(([a, b]) => [a, b].sort((x, y) => x - y)),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfLessThan = fc.record({
 	operation: fc.constant('if-lt' as const),
 	registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfGreaterThanOrEqualTo = fc.record({
 	operation: fc.constant('if-ge' as const),
 	registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfGreaterThan = fc.record({
 	operation: fc.constant('if-gt' as const),
 	registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfLessThanOrEqualTo = fc.record({
 	operation: fc.constant('if-le' as const),
 	registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 // If-test-zero operations (Format 21t)
 const arbitraryIfEqualZero = fc.record({
 	operation: fc.constant('if-eqz' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfNotEqualZero = fc.record({
 	operation: fc.constant('if-nez' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfLessThanZero = fc.record({
 	operation: fc.constant('if-ltz' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfGreaterThanOrEqualToZero = fc.record({
 	operation: fc.constant('if-gez' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfGreaterThanZero = fc.record({
 	operation: fc.constant('if-gtz' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 const arbitraryIfLessThanOrEqualToZero = fc.record({
 	operation: fc.constant('if-lez' as const),
 	registers: fc.tuple(arbitraryRegister8),
-	branchOffset: arbitraryBranchOffset16,
+	branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 
 // Array element operations (Format 23x)
@@ -740,7 +748,7 @@ const arbitraryIntToChar = createArbitraryUnaryOperation('int-to-char');
 const arbitraryIntToShort = createArbitraryUnaryOperation('int-to-short');
 
 // Combine all operations
-export const arbitraryDalvikBytecodeOperation: fc.Arbitrary<DalvikBytecodeOperation> = fc.oneof(
+export const arbitraryRawDalvikBytecodeOperation: fc.Arbitrary<RawDalvikBytecodeOperation> = fc.oneof(
 	arbitraryNop,
 	// Move operations
 	arbitraryMove,
@@ -986,7 +994,7 @@ export const arbitraryDalvikBytecodeOperation: fc.Arbitrary<DalvikBytecodeOperat
 );
 
 // Arbitrary for complete Dalvik bytecode (array of operations)
-export const arbitraryDalvikBytecode: fc.Arbitrary<DalvikBytecode> = fc.array(
-	arbitraryDalvikBytecodeOperation,
+export const arbitraryRawDalvikBytecode: fc.Arbitrary<RawDalvikBytecode> = fc.array(
+	arbitraryRawDalvikBytecodeOperation,
 	{ minLength: 0, maxLength: 100 }
 );

package/src/arbitraryDalvikExecutable.ts

@@ -288,52 +288,97 @@ const arbitraryDalvikExecutableDebugInfo: fc.Arbitrary<DalvikExecutableDebugInfo
 
 // Try-catch handler generators
 interface DalvikExecutableTry {
-	startAddress: number;
+	startInstructionIndex: number;
 	instructionCount: number;
 	handler: DalvikExecutableEncodedCatchHandler;
 }
 
 interface DalvikExecutableEncodedCatchHandler {
 	handlers: DalvikExecutableEncodedTypeAddressPair[];
-	catchAllAddress: undefined | number;
+	catchAllInstructionIndex: undefined | number;
 }
 
 interface DalvikExecutableEncodedTypeAddressPair {
 	type: string;
-	address: number;
+	handlerInstructionIndex: number;
 }
 
-const arbitraryDalvikExecutableEncodedTypeAddressPair: fc.Arbitrary<DalvikExecutableEncodedTypeAddressPair> = fc.record({
-	type: arbitraryDalvikClassName,
-	address: fc.nat({ max: 65535 }),
-});
+// Factory function to create arbitrary try blocks that are valid for given instruction count
+// Since addresses are now instruction indices, they must be within [0, instructionCount]
+function createArbitraryDalvikExecutableTry(instructionCount: number): fc.Arbitrary<DalvikExecutableTry> {
+	// If no instructions, we can't have meaningful try blocks
+	if (instructionCount === 0) {
+		// Return a try block that covers the "after last instruction" position (index 0)
+		const arbitraryEmptyHandler: fc.Arbitrary<DalvikExecutableEncodedCatchHandler> = fc.record({
+			handlers: fc.constant([]),
+			catchAllInstructionIndex: fc.constant(0),
+		});
+		return fc.record({
+			startInstructionIndex: fc.constant(0),
+			instructionCount: fc.constant(0),
+			handler: arbitraryEmptyHandler,
+		});
+	}
+
+	// Addresses must be in range [0, instructionCount] (inclusive, since handler can point to end)
+	const maxAddress = instructionCount;
+
+	const arbitraryDalvikExecutableEncodedTypeAddressPair: fc.Arbitrary<DalvikExecutableEncodedTypeAddressPair> = fc.record({
+		type: arbitraryDalvikClassName,
+		handlerInstructionIndex: fc.nat({ max: maxAddress }),
+	});
 
-const arbitraryDalvikExecutableEncodedCatchHandler: fc.Arbitrary<DalvikExecutableEncodedCatchHandler> = fc.record({
-	handlers: fc.array(arbitraryDalvikExecutableEncodedTypeAddressPair, { maxLength: 3 }),
-	catchAllAddress: fc.option(fc.nat({ max: 65535 }), { nil: undefined }),
-}).filter(handler => {
-	// A handler must have at least one typed handler OR a catch-all address
-	return handler.handlers.length > 0 || handler.catchAllAddress !== undefined;
-});
+	const arbitraryDalvikExecutableEncodedCatchHandler: fc.Arbitrary<DalvikExecutableEncodedCatchHandler> = fc.record({
+		handlers: fc.array(arbitraryDalvikExecutableEncodedTypeAddressPair, { maxLength: 3 }),
+		catchAllInstructionIndex: fc.option(fc.nat({ max: maxAddress }), { nil: undefined }),
+	}).filter(handler => {
+		// A handler must have at least one typed handler OR a catch-all address
+		return handler.handlers.length > 0 || handler.catchAllInstructionIndex !== undefined;
+	});
 
-const arbitraryDalvikExecutableTry: fc.Arbitrary<DalvikExecutableTry> = fc.record({
-	startAddress: fc.nat({ max: 65535 }),
-	instructionCount: fc.nat({ max: 255 }),
-	handler: arbitraryDalvikExecutableEncodedCatchHandler,
-});
+	// startInstructionIndex + instructionCount must not exceed instructionCount (the total)
+	return fc.tuple(
+		fc.nat({ max: instructionCount }),
+		fc.nat({ max: instructionCount }),
+	).chain(([start, count]) => {
+		// Adjust count so start + count <= instructionCount
+		const adjustedCount = Math.min(count, instructionCount - start);
+		return fc.record({
+			startInstructionIndex: fc.constant(start),
+			instructionCount: fc.constant(adjustedCount),
+			handler: arbitraryDalvikExecutableEncodedCatchHandler,
+		});
+	});
+}
+
+// Helper function to get instruction count from instructions
+// This handles both array and non-array instruction types
+function getInstructionCount<Instructions>(instructions: Instructions): number {
+	if (Array.isArray(instructions)) {
+		return instructions.length;
+	}
+
+	return 0; // Non-array instructions default to 0
+}
 
 // Generic factory function for DalvikExecutable
 export const createArbitraryDalvikExecutable = <Instructions>(
 	arbitraryInstructions: fc.Arbitrary<Instructions>,
 ): fc.Arbitrary<DalvikExecutable<Instructions>> => {
 	// Code generator using provided instructions arbitrary
+	// First generate instructions, then generate valid tries based on instruction count
 	const arbitraryDalvikExecutableCode: fc.Arbitrary<DalvikExecutableCode<Instructions>> = fc.record({
 		registersSize: fc.nat({ max: 65535 }),
 		insSize: fc.nat({ max: 255 }),
 		outsSize: fc.nat({ max: 255 }),
 		debugInfo: fc.option(arbitraryDalvikExecutableDebugInfo, { nil: undefined }),
 		instructions: arbitraryInstructions,
-		tries: fc.array(arbitraryDalvikExecutableTry, { maxLength: 2 }),
+	}).chain(partialCode => {
+		const instructionCount = getInstructionCount(partialCode.instructions);
+		return fc.array(createArbitraryDalvikExecutableTry(instructionCount), { maxLength: 2 }).map(tries => ({
+			...partialCode,
+			tries,
+		}));
 	});
 
 	// Method with access and code