@futpib/parser 1.0.4 → 1.0.6

package/src/dalvikBytecodeUnparser/formatUnparsers.ts

@@ -1,4 +1,5 @@
 import { type Unparser } from '../unparser.js';
+import { type CodeUnit, isoCodeUnit } from '../dalvikExecutableParser/typedNumbers.js';
 
 // Basic type unparsers
 export const ubyteUnparser: Unparser<number, Uint8Array> = async function * (input) {
@@ -55,13 +56,13 @@ export const nibblesUnparser: Unparser<[ number, number ], Uint8Array> = async f
 	yield * ubyteUnparser(byte, unparserContext);
 };
 
-// Format 10t: branchOffset (1 byte signed)
+// Format 10t: branchOffsetCodeUnit (1 byte signed)
 type DalvikBytecodeFormat10t = {
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 };
 
 export const dalvikBytecodeFormat10tUnparser: Unparser<DalvikBytecodeFormat10t, Uint8Array> = async function * (input, unparserContext) {
-	yield * byteUnparser(input.branchOffset, unparserContext);
+	yield * byteUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 
 // Format 10x: no data
@@ -104,14 +105,14 @@ export const dalvikBytecodeFormat12xReversedUnparser: Unparser<DalvikBytecodeFor
 	yield * nibblesUnparser([ input.registers[1], input.registers[0] ], unparserContext);
 };
 
-// Format 20t: zero byte + branchOffset (2 bytes signed)
+// Format 20t: zero byte + branchOffsetCodeUnit (2 bytes signed)
 type DalvikBytecodeFormat20t = {
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 };
 
 export const dalvikBytecodeFormat20tUnparser: Unparser<DalvikBytecodeFormat20t, Uint8Array> = async function * (input, unparserContext) {
 	yield * ubyteUnparser(0, unparserContext);
-	yield * shortUnparser(input.branchOffset, unparserContext);
+	yield * shortUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 
 // Format 21c: register + index (2 bytes)
@@ -136,15 +137,15 @@ export const dalvikBytecodeFormat21hUnparser: Unparser<DalvikBytecodeFormat21h,
 	yield * ushortUnparser(input.value, unparserContext);
 };
 
-// Format 21t: register + branchOffset (2 bytes signed)
+// Format 21t: register + branchOffsetCodeUnit (2 bytes signed)
 type DalvikBytecodeFormat21t = {
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 	registers: number[];
 };
 
 export const dalvikBytecodeFormat21tUnparser: Unparser<DalvikBytecodeFormat21t, Uint8Array> = async function * (input, unparserContext) {
 	yield * ubyteUnparser(input.registers[0], unparserContext);
-	yield * shortUnparser(input.branchOffset, unparserContext);
+	yield * shortUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 
 // Format 21s: register + value (2 bytes signed)
@@ -192,22 +193,22 @@ export const dalvikBytecodeFormat22sUnparser: Unparser<DalvikBytecodeFormat22s,
 	yield * shortUnparser(input.value, unparserContext);
 };
 
-// Format 22t: two registers in nibbles + branchOffset (2 bytes signed)
+// Format 22t: two registers in nibbles + branchOffsetCodeUnit (2 bytes signed)
 type DalvikBytecodeFormat22t = {
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 	registers: number[];
 };
 
 export const dalvikBytecodeFormat22tUnparser: Unparser<DalvikBytecodeFormat22t, Uint8Array> = async function * (input, unparserContext) {
 	yield * nibblesUnparser([ input.registers[1], input.registers[0] ], unparserContext);
-	yield * shortUnparser(input.branchOffset, unparserContext);
+	yield * shortUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 
 // Format 22t for commutative operations (if-eq, if-ne): registers are already in sorted/canonical order
 // so we don't reverse them
 export const dalvikBytecodeFormat22tCommutativeUnparser: Unparser<DalvikBytecodeFormat22t, Uint8Array> = async function * (input, unparserContext) {
 	yield * nibblesUnparser([ input.registers[0], input.registers[1] ], unparserContext);
-	yield * shortUnparser(input.branchOffset, unparserContext);
+	yield * shortUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 
 // Format 22x: register + register (2 bytes)
@@ -231,13 +232,13 @@ export const dalvikBytecodeFormat23xUnparser: Unparser<DalvikBytecodeFormat23x,
 	yield * ubyteUnparser(input.registers[2], unparserContext);
 };
 
-// Format 30t: zero byte + branchOffset (4 bytes signed)
+// Format 30t: zero byte + branchOffsetCodeUnit (4 bytes signed)
 type DalvikBytecodeFormat30t = {
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 };
 
 export const dalvikBytecodeFormat30tUnparser: Unparser<DalvikBytecodeFormat30t, Uint8Array> = async function * (input, unparserContext) {
-	yield * intUnparser(input.branchOffset, unparserContext);
+	yield * intUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 
 // Format 31i: register + value (4 bytes signed)
@@ -262,15 +263,15 @@ export const dalvikBytecodeFormat31cUnparser: Unparser<DalvikBytecodeFormat31c,
 	yield * uintUnparser(input.index, unparserContext);
 };
 
-// Format 31t: register + branchOffset (4 bytes signed)
+// Format 31t: register + branchOffsetCodeUnit (4 bytes signed)
 type DalvikBytecodeFormat31t = {
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 	registers: number[];
 };
 
 export const dalvikBytecodeFormat31tUnparser: Unparser<DalvikBytecodeFormat31t, Uint8Array> = async function * (input, unparserContext) {
 	yield * ubyteUnparser(input.registers[0], unparserContext);
-	yield * intUnparser(input.branchOffset, unparserContext);
+	yield * intUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 
 // Format 32x: two registers (2 bytes each)
@@ -374,19 +375,19 @@ export const dalvikBytecodeFormat4rccUnparser: Unparser<DalvikBytecodeFormat4rcc
 type DalvikBytecodeOperationPackedSwitchPayload = {
 	operation: 'packed-switch-payload';
 	value: number;
-	branchOffsets: number[];
+	branchOffsetsCodeUnit: CodeUnit[];
 };
 
 export const dalvikBytecodeOperationPackedSwitchPayloadUnparser: Unparser<DalvikBytecodeOperationPackedSwitchPayload, Uint8Array> = async function * (input, unparserContext) {
 	// Ident (0x0100) - little-endian
 	yield * ushortUnparser(0x01_00, unparserContext);
 	// Size
-	yield * ushortUnparser(input.branchOffsets.length, unparserContext);
+	yield * ushortUnparser(input.branchOffsetsCodeUnit.length, unparserContext);
 	// First key value
 	yield * intUnparser(input.value, unparserContext);
 	// Branch offsets
-	for (const offset of input.branchOffsets) {
-		yield * intUnparser(offset, unparserContext);
+	for (const offset of input.branchOffsetsCodeUnit) {
+		yield * intUnparser(isoCodeUnit.unwrap(offset), unparserContext);
 	}
 };
 
@@ -394,7 +395,7 @@ export const dalvikBytecodeOperationPackedSwitchPayloadUnparser: Unparser<Dalvik
 type DalvikBytecodeOperationSparseSwitchPayload = {
 	operation: 'sparse-switch-payload';
 	keys: number[];
-	branchOffsets: number[];
+	branchOffsetsCodeUnit: CodeUnit[];
 };
 
 export const dalvikBytecodeOperationSparseSwitchPayloadUnparser: Unparser<DalvikBytecodeOperationSparseSwitchPayload, Uint8Array> = async function * (input, unparserContext) {
@@ -407,8 +408,8 @@ export const dalvikBytecodeOperationSparseSwitchPayloadUnparser: Unparser<Dalvik
 		yield * intUnparser(key, unparserContext);
 	}
 	// Branch offsets
-	for (const offset of input.branchOffsets) {
-		yield * intUnparser(offset, unparserContext);
+	for (const offset of input.branchOffsetsCodeUnit) {
+		yield * intUnparser(isoCodeUnit.unwrap(offset), unparserContext);
 	}
 };
 

package/src/dalvikBytecodeUnparser.test.ts

@@ -1,22 +1,22 @@
 import { testProp } from '@fast-check/ava';
 import { runUnparser } from './unparser.js';
-import { dalvikBytecodeUnparser } from './dalvikBytecodeUnparser.js';
+import { rawDalvikBytecodeUnparser } from './dalvikBytecodeUnparser.js';
 import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
 import { runParser } from './parser.js';
-import { createDalvikBytecodeParser } from './dalvikBytecodeParser.js';
+import { createRawDalvikBytecodeParser } from './dalvikBytecodeParser.js';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
-import { arbitraryDalvikBytecode } from './arbitraryDalvikBytecode.js';
+import { arbitraryRawDalvikBytecode } from './arbitraryDalvikBytecode.js';
 import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
 
 const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
 
 testProp(
 	'dalvik bytecode roundtrip',
-	[arbitraryDalvikBytecode],
+	[arbitraryRawDalvikBytecode],
 	async (t, bytecode) => {
 		// Unparse the bytecode to bytes
 		const unparsedStreamIterable = runUnparser(
-			dalvikBytecodeUnparser,
+			rawDalvikBytecodeUnparser,
 			bytecode,
 			uint8ArrayUnparserOutputCompanion
 		);
@@ -25,11 +25,11 @@ testProp(
 		const unparsedStream = await uint8ArrayAsyncIterableToUint8Array(unparsedStreamIterable);
 
 		// Create parser with the correct size
-		const dalvikBytecodeParser = createDalvikBytecodeParser(unparsedStream.length);
+		const rawDalvikBytecodeParser = createRawDalvikBytecodeParser(unparsedStream.length);
 
 		// Re-parse the unparsed bytes
 		const actual = await runParser(
-			dalvikBytecodeParser,
+			rawDalvikBytecodeParser,
 			unparsedStream,
 			uint8ArrayParserInputCompanion
 		);

package/src/dalvikBytecodeUnparser.ts

@@ -1,7 +1,8 @@
 import { type Unparser, type UnparserResult } from './unparser.js';
 import { type UnparserContext } from './unparserContext.js';
-import { type DalvikBytecode, type DalvikBytecodeOperation } from './dalvikBytecodeParser.js';
+import { type RawDalvikBytecode, type RawDalvikBytecodeOperation } from './dalvikBytecodeParser.js';
 import {
+	type CodeUnit,
 	isoIndexIntoStringIds,
 	isoIndexIntoTypeIds,
 	isoIndexIntoMethodIds,
@@ -312,26 +313,26 @@ const operationToOpcodeMap: Map<string, number> = new Map([
 	// They use multi-byte identifiers: 0x0100, 0x0200, 0x0300
 ]);
 
-export const dalvikBytecodeUnparser: Unparser<DalvikBytecode, Uint8Array> = async function * (input, unparserContext) {
+export const rawDalvikBytecodeUnparser: Unparser<RawDalvikBytecode, Uint8Array> = async function * (input, unparserContext) {
 	for (const operation of input) {
-		yield * dalvikBytecodeOperationUnparser(operation, unparserContext);
+		yield * rawDalvikBytecodeOperationUnparser(operation, unparserContext);
 	}
 };
 
 // Type guards for payload operations
-function isPackedSwitchPayload(op: DalvikBytecodeOperation): op is { operation: 'packed-switch-payload'; value: number; branchOffsets: number[] } {
+function isPackedSwitchPayload(op: RawDalvikBytecodeOperation): op is RawDalvikBytecodeOperation & { operation: 'packed-switch-payload' } {
 	return typeof op === 'object' && op !== null && 'operation' in op && op.operation === 'packed-switch-payload';
 }
 
-function isSparseSwitchPayload(op: DalvikBytecodeOperation): op is { operation: 'sparse-switch-payload'; keys: number[]; branchOffsets: number[] } {
+function isSparseSwitchPayload(op: RawDalvikBytecodeOperation): op is RawDalvikBytecodeOperation & { operation: 'sparse-switch-payload' } {
 	return typeof op === 'object' && op !== null && 'operation' in op && op.operation === 'sparse-switch-payload';
 }
 
-function isFillArrayDataPayload(op: DalvikBytecodeOperation): op is { operation: 'fill-array-data-payload'; elementWidth: number; data: number[] } {
+function isFillArrayDataPayload(op: RawDalvikBytecodeOperation): op is RawDalvikBytecodeOperation & { operation: 'fill-array-data-payload' } {
 	return typeof op === 'object' && op !== null && 'operation' in op && op.operation === 'fill-array-data-payload';
 }
 
-const dalvikBytecodeOperationUnparser: Unparser<DalvikBytecodeOperation, Uint8Array> = async function * (operation, unparserContext) {
+const rawDalvikBytecodeOperationUnparser: Unparser<RawDalvikBytecodeOperation, Uint8Array> = async function * (operation, unparserContext) {
 	if (!operation || typeof operation !== 'object' || !('operation' in operation)) {
 		throw new Error('Invalid operation');
 	}
@@ -374,19 +375,19 @@ const dalvikBytecodeOperationUnparser: Unparser<DalvikBytecodeOperation, Uint8Ar
 };
 
 // Helper to check if operation has specific fields
-function hasRegisters(op: DalvikBytecodeOperation): op is DalvikBytecodeOperation & { registers: number[] } {
+function hasRegisters(op: RawDalvikBytecodeOperation): op is RawDalvikBytecodeOperation & { registers: number[] } {
 	return 'registers' in op;
 }
 
-function hasValue(op: DalvikBytecodeOperation): op is DalvikBytecodeOperation & { value: number | bigint } {
+function hasValue(op: RawDalvikBytecodeOperation): op is RawDalvikBytecodeOperation & { value: number | bigint } {
 	return 'value' in op;
 }
 
-function hasBranchOffset(op: DalvikBytecodeOperation): op is DalvikBytecodeOperation & { branchOffset: number } {
-	return 'branchOffset' in op;
+function hasBranchOffsetCodeUnit(op: RawDalvikBytecodeOperation): op is RawDalvikBytecodeOperation & { branchOffsetCodeUnit: CodeUnit } {
+	return 'branchOffsetCodeUnit' in op;
 }
 
-async function * unparseOperationData(operation: DalvikBytecodeOperation, unparserContext: UnparserContext<Uint8Array, number>): UnparserResult<Uint8Array, number> {
+async function * unparseOperationData(operation: RawDalvikBytecodeOperation, unparserContext: UnparserContext<Uint8Array, number>): UnparserResult<Uint8Array, number> {
 	if (!('operation' in operation)) {
 		throw new Error('Invalid operation structure');
 	}
@@ -601,59 +602,59 @@ async function * unparseOperationData(operation: DalvikBytecodeOperation, unpars
 
 	// Format 10t (goto)
 	if (operationName === 'goto') {
-		if (!hasBranchOffset(operation)) {
-			throw new Error(`Operation ${operationName} missing branchOffset field`);
+		if (!hasBranchOffsetCodeUnit(operation)) {
+			throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit field`);
 		}
-		yield * dalvikBytecodeFormat10tUnparser({ branchOffset: operation.branchOffset }, unparserContext);
+		yield * dalvikBytecodeFormat10tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit }, unparserContext);
 		return;
 	}
 
 	// Format 20t (goto/16)
 	if (operationName === 'goto/16') {
-		if (!hasBranchOffset(operation)) {
-			throw new Error(`Operation ${operationName} missing branchOffset field`);
+		if (!hasBranchOffsetCodeUnit(operation)) {
+			throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit field`);
 		}
-		yield * dalvikBytecodeFormat20tUnparser({ branchOffset: operation.branchOffset }, unparserContext);
+		yield * dalvikBytecodeFormat20tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit }, unparserContext);
 		return;
 	}
 
 	// Format 30t (goto/32)
 	if (operationName === 'goto/32') {
-		if (!hasBranchOffset(operation)) {
-			throw new Error(`Operation ${operationName} missing branchOffset field`);
+		if (!hasBranchOffsetCodeUnit(operation)) {
+			throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit field`);
 		}
-		yield * dalvikBytecodeFormat30tUnparser({ branchOffset: operation.branchOffset }, unparserContext);
+		yield * dalvikBytecodeFormat30tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit }, unparserContext);
 		return;
 	}
 
 	// Format 22t (if-* operations)
 	if (operationName.startsWith('if-') && !operationName.endsWith('z')) {
-		if (!hasBranchOffset(operation) || !hasRegisters(operation)) {
-			throw new Error(`Operation ${operationName} missing branchOffset or registers field`);
+		if (!hasBranchOffsetCodeUnit(operation) || !hasRegisters(operation)) {
+			throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit or registers field`);
 		}
 		// Commutative operations (if-eq, if-ne) have sorted registers, so don't reverse
 		const isCommutative = operationName === 'if-eq' || operationName === 'if-ne';
 		const unparser = isCommutative ? dalvikBytecodeFormat22tCommutativeUnparser : dalvikBytecodeFormat22tUnparser;
-		yield * unparser({ branchOffset: operation.branchOffset, registers: operation.registers }, unparserContext);
+		yield * unparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit, registers: operation.registers }, unparserContext);
 		return;
 	}
 
 	// Format 21t (if-*z operations)
 	if (operationName.startsWith('if-') && operationName.endsWith('z')) {
-		if (!hasBranchOffset(operation) || !hasRegisters(operation)) {
-			throw new Error(`Operation ${operationName} missing branchOffset or registers field`);
+		if (!hasBranchOffsetCodeUnit(operation) || !hasRegisters(operation)) {
+			throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit or registers field`);
 		}
-		yield * dalvikBytecodeFormat21tUnparser({ branchOffset: operation.branchOffset, registers: operation.registers }, unparserContext);
+		yield * dalvikBytecodeFormat21tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit, registers: operation.registers }, unparserContext);
 		return;
 	}
 
 	// Format 31t (packed-switch, sparse-switch, fill-array-data)
 	if (operationName === 'packed-switch' || operationName === 'sparse-switch' ||
 	    operationName === 'fill-array-data') {
-		if (!hasBranchOffset(operation) || !hasRegisters(operation)) {
-			throw new Error(`Operation ${operationName} missing branchOffset or registers field`);
+		if (!hasBranchOffsetCodeUnit(operation) || !hasRegisters(operation)) {
+			throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit or registers field`);
 		}
-		yield * dalvikBytecodeFormat31tUnparser({ branchOffset: operation.branchOffset, registers: operation.registers }, unparserContext);
+		yield * dalvikBytecodeFormat31tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit, registers: operation.registers }, unparserContext);
 		return;
 	}
 

package/src/dalvikExecutable.test-d.ts

@@ -0,0 +1,132 @@
+import { expectType } from 'tsd';
+import { type ParserOutput } from './parser.js';
+import { dalvikExecutableParser } from './dalvikExecutableParser.js';
+
+// Test that DalvikExecutable instruction index fields use plain number types
+// This ensures typed numbers (CodeUnit, InstructionIndex) do not leak into the public API
+
+// Derive types from the actual parser output
+type ParsedDalvikExecutable = ParserOutput<typeof dalvikExecutableParser>;
+type ParsedClassDefinition = ParsedDalvikExecutable['classDefinitions'][number];
+type ParsedClassData = NonNullable<ParsedClassDefinition['classData']>;
+type ParsedMethod = ParsedClassData['directMethods'][number];
+type ParsedCode = NonNullable<ParsedMethod['code']>;
+type ParsedInstructions = ParsedCode['instructions'];
+type ParsedOperation = ParsedInstructions[number];
+
+// Test try/catch block types
+declare const dex: ParsedDalvikExecutable;
+const classDef = dex.classDefinitions[0];
+const classData = classDef.classData!;
+const method = classData.directMethods[0];
+const code = method.code!;
+
+// Try block field types
+const tryBlock = code.tries[0];
+expectType<number>(tryBlock.startInstructionIndex);
+expectType<number>(tryBlock.instructionCount);
+
+// Handler field types
+const handler = tryBlock.handler;
+expectType<number | undefined>(handler.catchAllInstructionIndex);
+
+// Type-address pair field types
+const typeAddressPair = handler.handlers[0];
+expectType<number>(typeAddressPair.handlerInstructionIndex);
+
+// Test bytecode operation types - branch offsets should be plain numbers
+type GotoOperation = Extract<ParsedOperation, { operation: 'goto' }>;
+declare const gotoOp: GotoOperation;
+expectType<number>(gotoOp.targetInstructionIndex);
+
+type Goto16Operation = Extract<ParsedOperation, { operation: 'goto/16' }>;
+declare const goto16Op: Goto16Operation;
+expectType<number>(goto16Op.targetInstructionIndex);
+
+type Goto32Operation = Extract<ParsedOperation, { operation: 'goto/32' }>;
+declare const goto32Op: Goto32Operation;
+expectType<number>(goto32Op.targetInstructionIndex);
+
+type PackedSwitchOperation = Extract<ParsedOperation, { operation: 'packed-switch' }>;
+declare const packedSwitchOp: PackedSwitchOperation;
+expectType<number>(packedSwitchOp.targetInstructionIndex);
+
+type SparseSwitchOperation = Extract<ParsedOperation, { operation: 'sparse-switch' }>;
+declare const sparseSwitchOp: SparseSwitchOperation;
+expectType<number>(sparseSwitchOp.targetInstructionIndex);
+
+type PackedSwitchPayloadOperation = Extract<ParsedOperation, { operation: 'packed-switch-payload' }>;
+declare const packedSwitchPayloadOp: PackedSwitchPayloadOperation;
+expectType<number[]>(packedSwitchPayloadOp.targetInstructionIndices);
+
+type SparseSwitchPayloadOperation = Extract<ParsedOperation, { operation: 'sparse-switch-payload' }>;
+declare const sparseSwitchPayloadOp: SparseSwitchPayloadOperation;
+expectType<number[]>(sparseSwitchPayloadOp.targetInstructionIndices);
+
+type FillArrayDataOperation = Extract<ParsedOperation, { operation: 'fill-array-data' }>;
+declare const fillArrayDataOp: FillArrayDataOperation;
+expectType<number>(fillArrayDataOp.targetInstructionIndex);
+
+type IfEqOperation = Extract<ParsedOperation, { operation: 'if-eq' }>;
+declare const ifEqOp: IfEqOperation;
+expectType<number>(ifEqOp.targetInstructionIndex);
+
+type IfEqzOperation = Extract<ParsedOperation, { operation: 'if-eqz' }>;
+declare const ifEqzOp: IfEqzOperation;
+expectType<number>(ifEqzOp.targetInstructionIndex);
+
+// Test that index fields are resolved to their actual types (not raw indices)
+// Operations with methodIndex should have method: DalvikExecutableMethod
+type InvokeVirtualOperation = Extract<ParsedOperation, { operation: 'invoke-virtual' }>;
+declare const invokeVirtualOp: InvokeVirtualOperation;
+expectType<{ class: string; prototype: { shorty: string; returnType: string; parameters: string[] }; name: string }>(invokeVirtualOp.method);
+
+// Operations with fieldIndex should have field: DalvikExecutableField
+type IgetOperation = Extract<ParsedOperation, { operation: 'iget' }>;
+declare const igetOp: IgetOperation;
+expectType<{ class: string; type: string; name: string }>(igetOp.field);
+
+// Operations with typeIndex should have type: string
+type CheckCastOperation = Extract<ParsedOperation, { operation: 'check-cast' }>;
+declare const checkCastOp: CheckCastOperation;
+expectType<string>(checkCastOp.type);
+
+// Operations with stringIndex should have string: string
+type ConstStringOperation = Extract<ParsedOperation, { operation: 'const-string' }>;
+declare const constStringOp: ConstStringOperation;
+expectType<string>(constStringOp.string);
+
+// Test that raw index fields do NOT exist on resolved types
+// @ts-expect-error - methodIndex should not exist, use method instead
+invokeVirtualOp.methodIndex;
+// @ts-expect-error - fieldIndex should not exist, use field instead
+igetOp.fieldIndex;
+// @ts-expect-error - typeIndex should not exist, use type instead
+checkCastOp.typeIndex;
+// @ts-expect-error - stringIndex should not exist, use string instead
+constStringOp.stringIndex;
+
+// Test that values can be constructed with resolved fields
+const _invokeVirtual: InvokeVirtualOperation = {
+	operation: 'invoke-virtual',
+	registers: [0],
+	method: { class: 'Lfoo/Bar;', prototype: { shorty: 'V', returnType: 'V', parameters: [] }, name: 'baz' },
+};
+
+const _iget: IgetOperation = {
+	operation: 'iget',
+	registers: [0, 1],
+	field: { class: 'Lfoo/Bar;', type: 'I', name: 'x' },
+};
+
+const _checkCast: CheckCastOperation = {
+	operation: 'check-cast',
+	registers: [0],
+	type: 'Lfoo/Bar;',
+};
+
+const _constString: ConstStringOperation = {
+	operation: 'const-string',
+	registers: [0],
+	string: 'hello',
+};

package/src/dalvikExecutable.ts

@@ -67,19 +67,19 @@ export type DalvikExecutableEncodedValue =
 	| { type: 'boolean'; value: boolean };
 
 type DalvikExecutableTry = {
-	startAddress: number;
+	startInstructionIndex: number;
 	instructionCount: number;
 	handler: DalvikExecutableEncodedCatchHandler;
 };
 
 type DalvikExecutableEncodedTypeAddressPair = {
 	type: string;
-	address: number;
+	handlerInstructionIndex: number;
 };
 
 type DalvikExecutableEncodedCatchHandler = {
 	handlers: DalvikExecutableEncodedTypeAddressPair[];
-	catchAllAddress: undefined | number;
+	catchAllInstructionIndex: undefined | number;
 };
 
 export type DalvikExecutableCode<Instructions> = {

package/src/dalvikExecutableParser/typedNumbers.ts

@@ -15,6 +15,17 @@ export const isoIndexIntoFieldIds = iso<IndexIntoFieldIds>();
 export type IndexIntoMethodIds = {} & Newtype<{ readonly IndexIntoMethodIds: unique symbol }, number>;
 export const isoIndexIntoMethodIds = iso<IndexIntoMethodIds>();
 
+export type IndexIntoCallSiteIds = {} & Newtype<{ readonly IndexIntoCallSiteIds: unique symbol }, number>;
+export const isoIndexIntoCallSiteIds = iso<IndexIntoCallSiteIds>();
+
+// Code unit addresses/offsets (raw DEX format, 16-bit code units)
+export type CodeUnit = {} & Newtype<{ readonly CodeUnit: unique symbol }, number>;
+export const isoCodeUnit = iso<CodeUnit>();
+
+// Instruction index addresses/offsets (converted format, instruction-relative)
+export type InstructionIndex = {} & Newtype<{ readonly InstructionIndex: unique symbol }, number>;
+export const isoInstructionIndex = iso<InstructionIndex>();
+
 export type OffsetToStringDataItem = {} & Newtype<{ readonly OffsetToStringDataItem: unique symbol }, number>;
 export const isoOffsetToStringDataItem = iso<OffsetToStringDataItem>();
 

package/src/dalvikExecutableParser.test.ts

@@ -70,8 +70,10 @@ const dexWithParsedInstructionsMacro = test.macro({
 				return;
 			}
 
-			t.false(key.endsWith('Offset') && key !== 'branchOffset', 'All offsets should be resolved: ' + path.join('.'));
-			t.false(key.endsWith('Index'), 'All indexes should be resolved: ' + path.join('.'));
+			t.false(key.endsWith('Offset'), 'All offsets should be resolved: ' + path.join('.'));
+			// InstructionIndex fields are expected in Tier 3
+			const allowedIndexFields = ['targetInstructionIndex', 'targetInstructionIndices', 'startInstructionIndex', 'handlerInstructionIndex', 'catchAllInstructionIndex'];
+			t.false(key.endsWith('Index') && !allowedIndexFields.includes(key) && key !== 'targetInstructionIndices', 'All indexes should be resolved: ' + path.join('.'));
 		});
 
 		if (shouldSnapshot) {
@@ -83,7 +85,39 @@ const dexWithParsedInstructionsMacro = test.macro({
 	},
 });
 
-test.serial.only(dexWithParsedInstructionsMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true);
+test.serial(dexWithParsedInstructionsMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true);
 test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false);
 test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false);
 test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false);
+
+const methodMacro = test.macro({
+	title: (providedTitle, dexCid: string, className: string, methodName: string) =>
+		providedTitle ?? `method ${className}.${methodName} from ${dexCid}`,
+	async exec(t, dexCid: string, className: string, methodName: string) {
+		const dexStream = await fetchCid(dexCid);
+
+		const dex = await runParser(dalvikExecutableParser, dexStream, uint8ArrayParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		const classDef = dex.classDefinitions.find(c => c.class === className);
+		t.truthy(classDef, `Class ${className} not found`);
+
+		const allMethods = [
+			...(classDef!.classData?.directMethods ?? []),
+			...(classDef!.classData?.virtualMethods ?? []),
+		];
+
+		const method = allMethods.find(m => m.method.name === methodName);
+		t.truthy(method, `Method ${methodName} not found in ${className}`);
+
+		t.snapshot(method);
+	},
+});
+
+test.serial(
+	methodMacro,
+	'bafkreifycfnx4xf3nlml4qavlyxr6bes66nxsow3iaqjghewfsozoj2h3q',
+	'Lpl/czak/minimal/MainActivity;',
+	'getPackedSwitchResult',
+);