@futpib/parser 1.0.3 → 1.0.6

package/build/dalvikExecutableParser/typedNumbers.d.ts

@@ -29,6 +29,24 @@ export type IndexIntoMethodIds = {} & Newtype<{
 export declare const isoIndexIntoMethodIds: import("monocle-ts").Iso<Newtype<{
     readonly IndexIntoMethodIds: unique symbol;
 }, number>, number>;
+export type IndexIntoCallSiteIds = {} & Newtype<{
+    readonly IndexIntoCallSiteIds: unique symbol;
+}, number>;
+export declare const isoIndexIntoCallSiteIds: import("monocle-ts").Iso<Newtype<{
+    readonly IndexIntoCallSiteIds: unique symbol;
+}, number>, number>;
+export type CodeUnit = {} & Newtype<{
+    readonly CodeUnit: unique symbol;
+}, number>;
+export declare const isoCodeUnit: import("monocle-ts").Iso<Newtype<{
+    readonly CodeUnit: unique symbol;
+}, number>, number>;
+export type InstructionIndex = {} & Newtype<{
+    readonly InstructionIndex: unique symbol;
+}, number>;
+export declare const isoInstructionIndex: import("monocle-ts").Iso<Newtype<{
+    readonly InstructionIndex: unique symbol;
+}, number>, number>;
 export type OffsetToStringDataItem = {} & Newtype<{
     readonly OffsetToStringDataItem: unique symbol;
 }, number>;

package/build/dalvikExecutableParser/typedNumbers.js

@@ -4,6 +4,9 @@ export const isoIndexIntoTypeIds = iso();
 export const isoIndexIntoPrototypeIds = iso();
 export const isoIndexIntoFieldIds = iso();
 export const isoIndexIntoMethodIds = iso();
+export const isoIndexIntoCallSiteIds = iso();
+export const isoCodeUnit = iso();
+export const isoInstructionIndex = iso();
 export const isoOffsetToStringDataItem = iso();
 export const isoOffsetToTypeList = iso();
 export const isoOffsetToAnnotationsDirectoryItem = iso();

package/build/dalvikExecutableParser.d.ts

@@ -1,5 +1,6 @@
 import { type Parser } from './parser.js';
-import { type DalvikBytecode } from './dalvikBytecodeParser.js';
+import { type DalvikBytecode } from './dalvikBytecodeParser/addressConversion.js';
 import { type DalvikExecutable } from './dalvikExecutable.js';
 export declare const dalvikExecutableParser: Parser<DalvikExecutable<DalvikBytecode>, Uint8Array>;
+export { type DalvikBytecodeOperation, type DalvikBytecode } from './dalvikBytecodeParser/addressConversion.js';
 export declare const dalvikExecutableWithRawInstructionsParser: Parser<DalvikExecutable<Uint8Array>, Uint8Array>;

package/build/dalvikExecutableParser.js

@@ -3,6 +3,7 @@ import { MUtf8Decoder } from 'mutf-8';
 import { createExactElementParser } from './exactElementParser.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { createObjectParser } from './objectParser.js';
 import { cloneParser, setParserName } from './parser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
 import { promiseCompose } from './promiseCompose.js';
@@ -16,8 +17,11 @@ import { sleb128NumberParser, uleb128NumberParser } from './leb128Parser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createElementTerminatedSequenceParser } from './elementTerminatedSequenceParser.js';
 import { createElementTerminatedArrayParserUnsafe } from './elementTerminatedArrayParser.js';
-import { createDalvikBytecodeParser, resolveDalvikBytecodeOperation, } from './dalvikBytecodeParser.js';
+import { createRawDalvikBytecodeParser, resolveRawDalvikBytecodeOperationIndices, } from './dalvikBytecodeParser.js';
+import { buildCodeUnitToIndexMap, codeUnitToInstructionIndex, convertBranchOffsetsToInstructionOffsets, unwrapBranchOffsets, } from './dalvikBytecodeParser/addressConversion.js';
+import { isoCodeUnit, isoInstructionIndex } from './dalvikExecutableParser/typedNumbers.js';
 import { byteParser, ubyteParser, uintParser, uleb128p1NumberParser, ushortParser, } from './dalvikExecutableParser/typeParsers.js';
+import { dalvikExecutableMethodEquals, } from './dalvikExecutable.js';
 // https://source.android.com/docs/core/runtime/dex-format
 const createByteAlignParser = (byteAlignment) => async (parserContext) => {
     const toSkip = (byteAlignment - (parserContext.position % byteAlignment)) % byteAlignment;
@@ -34,43 +38,27 @@ const dalvikExecutableHeaderVersionParser = promiseCompose(createTupleParser([
     const version = Number.parseInt(versionString, 10);
     return version;
 });
-const sizeOffsetParser = promiseCompose(createTupleParser([
-    uintParser,
-    uintParser,
-]), ([size, offset]) => ({ size, offset }));
-const dalvikExecutableHeaderItemParser = promiseCompose(createTupleParser([
-    dalvikExecutableHeaderVersionParser,
-    uintParser,
-    createFixedLengthSequenceParser(20),
-    uintParser,
-    uintParser,
-    uintParser,
-    sizeOffsetParser,
-    uintParser,
-    sizeOffsetParser,
-    sizeOffsetParser,
-    sizeOffsetParser,
-    sizeOffsetParser,
-    sizeOffsetParser,
-    sizeOffsetParser,
-    sizeOffsetParser,
-]), ([version, checksum, sha1Hash, fileSize, headerSize, endianTag, link, mapOffset, stringIds, typeIds, prototypeIds, fieldIds, methodIds, classDefinitions, data,]) => ({
-    version,
-    checksum,
-    sha1Hash,
-    fileSize,
-    headerSize,
-    endianTag,
-    link,
-    mapOffset,
-    stringIds,
-    typeIds,
-    prototypeIds,
-    fieldIds,
-    methodIds,
-    classDefinitions,
-    data,
-}));
+const sizeOffsetParser = createObjectParser({
+    size: uintParser,
+    offset: uintParser,
+});
+const dalvikExecutableHeaderItemParser = createObjectParser({
+    version: dalvikExecutableHeaderVersionParser,
+    checksum: uintParser,
+    sha1Hash: createFixedLengthSequenceParser(20),
+    fileSize: uintParser,
+    headerSize: uintParser,
+    endianTag: uintParser,
+    link: sizeOffsetParser,
+    mapOffset: uintParser,
+    stringIds: sizeOffsetParser,
+    typeIds: sizeOffsetParser,
+    prototypeIds: sizeOffsetParser,
+    fieldIds: sizeOffsetParser,
+    methodIds: sizeOffsetParser,
+    classDefinitions: sizeOffsetParser,
+    data: sizeOffsetParser,
+});
 const dalvikExecutableStringIdItemParser = promiseCompose(cloneParser(uintParser), offset => isoOffsetToStringDataItem.wrap(offset));
 const isoDalvikExecutableStringIdItems = getIsoTypedNumberArray();
 const createSkipToThenStringIdItemsParser = ({ size, offset }) => (size === 0
@@ -308,10 +296,10 @@ const createSkipToThenAnnotationsDirectoryItemsParser = (sizeOffset) => createSk
     isoOffset: isoOffsetToAnnotationsDirectoryItem,
     parserName: 'skipToThenAnnotationsDirectoryItemsParser',
 });
-const encodedFieldParser = promiseCompose(createTupleParser([
-    uleb128NumberParser,
-    uleb128FieldAccessFlagsParser,
-]), ([fieldIndexDiff, accessFlags]) => ({ fieldIndexDiff, accessFlags }));
+const encodedFieldParser = createObjectParser({
+    fieldIndexDiff: uleb128NumberParser,
+    accessFlags: uleb128FieldAccessFlagsParser,
+});
 const createEncodedFieldsParser = (fieldsSize) => promiseCompose(createQuantifierParser(encodedFieldParser, fieldsSize), encodedFields => {
     let previousFieldIndex = 0;
     return encodedFields.map(({ fieldIndexDiff, accessFlags }) => {
@@ -375,10 +363,11 @@ const createByteWith5LeastSignificantBitsEqualParser = (leastSignificant5) => {
     return byteWith5LeastSignificantBitsEqualParser;
 };
 const createEncodedValueArgParser = (valueType) => promiseCompose(createByteWith5LeastSignificantBitsEqualParser(valueType), byte => byte >> 5);
-const encodedValueByteParser = promiseCompose(createTupleParser([
-    createExactElementParser(0),
-    byteParser,
-]), ([_, value]) => ({ type: 'byte', value }));
+const encodedValueByteParser = createObjectParser({
+    type: 'byte',
+    _tag: createExactElementParser(0),
+    value: byteParser,
+});
 setParserName(encodedValueByteParser, 'encodedValueByteParser');
 const encodedValueShortParser = parserCreatorCompose(() => createEncodedValueArgParser(0x02), sizeSubOne => {
     const size = sizeSubOne + 1;
@@ -730,12 +719,13 @@ const encodedValueEnumParser = parserCreatorCompose(() => createEncodedValueArgP
 setParserName(encodedValueEnumParser, 'encodedValueEnumParser');
 const encodedArrayParser = parserCreatorCompose(() => uleb128NumberParser, size => createQuantifierParser(encodedValueParser, size))();
 setParserName(encodedArrayParser, 'encodedArrayParser');
-const encodedValueArrayParser = promiseCompose(createTupleParser([
-    parserCreatorCompose(() => createEncodedValueArgParser(0x1C), valueArg => parserContext => {
+const encodedValueArrayParser = createObjectParser({
+    type: 'array',
+    _tag: parserCreatorCompose(() => createEncodedValueArgParser(0x1C), valueArg => parserContext => {
         parserContext.invariant(valueArg === 0, '(encodedValueArrayParser) valueArg: %s', valueArg);
     })(),
-    encodedArrayParser,
-]), ([_, array]) => ({ type: 'array', value: array }));
+    value: encodedArrayParser,
+});
 setParserName(encodedValueArrayParser, 'encodedValueArrayParser');
 const annotationElementParser = promiseCompose(createTupleParser([
     uleb128NumberParser,
@@ -756,12 +746,13 @@ const encodedAnnotationParser = promiseCompose(parserCreatorCompose(() => create
     elements,
 }));
 setParserName(encodedAnnotationParser, 'encodedAnnotationParser');
-const encodedValueAnnotationParser = promiseCompose(createTupleParser([
-    parserCreatorCompose(() => createEncodedValueArgParser(0x1D), valueArg => parserContext => {
+const encodedValueAnnotationParser = createObjectParser({
+    type: 'annotation',
+    _tag: parserCreatorCompose(() => createEncodedValueArgParser(0x1D), valueArg => parserContext => {
         parserContext.invariant(valueArg === 0, '(encodedValueAnnotationParser) valueArg: %s', valueArg);
     })(),
-    encodedAnnotationParser,
-]), ([_, annotation]) => ({ type: 'annotation', value: annotation }));
+    value: encodedAnnotationParser,
+});
 setParserName(encodedValueAnnotationParser, 'encodedValueAnnotationParser');
 const encodedValueNullParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1E), valueArg => parserContext => {
     parserContext.invariant(valueArg === 0, '(encodedValueNullParser) valueArg: %s', valueArg);
@@ -875,10 +866,16 @@ const createSkipToThenCodeItemsParser = ({ sizeOffset, createInstructionsParser,
 const dalvikExecutableDebugByteCodeValueParser = parserCreatorCompose(() => ubyteParser, (value) => {
     switch (value) {
         case 0x01: {
-            return promiseCompose(uleb128NumberParser, addressDiff => ({ type: 'advancePc', addressDiff }));
+            return createObjectParser({
+                type: 'advancePc',
+                addressDiff: uleb128NumberParser,
+            });
         }
         case 0x02: {
-            return promiseCompose(sleb128NumberParser, lineDiff => ({ type: 'advanceLine', lineDiff }));
+            return createObjectParser({
+                type: 'advanceLine',
+                lineDiff: sleb128NumberParser,
+            });
         }
         case 0x03: {
             return promiseCompose(createTupleParser([
@@ -969,10 +966,10 @@ const dalvikExecutableAnnotationItemVisibilityParser = promiseCompose(ubyteParse
     }
 });
 setParserName(dalvikExecutableAnnotationItemVisibilityParser, 'dalvikExecutableAnnotationItemVisibilityParser');
-const dalvikExecutableAnnotationItemParser = promiseCompose(createTupleParser([
-    dalvikExecutableAnnotationItemVisibilityParser,
-    encodedAnnotationParser,
-]), ([visibility, encodedAnnotation]) => ({ visibility, encodedAnnotation }));
+const dalvikExecutableAnnotationItemParser = createObjectParser({
+    visibility: dalvikExecutableAnnotationItemVisibilityParser,
+    encodedAnnotation: encodedAnnotationParser,
+});
 setParserName(dalvikExecutableAnnotationItemParser, 'dalvikExecutableAnnotationItemParser');
 const createSkipToThenAnnotationItemsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
     sizeOffset,
@@ -1078,12 +1075,12 @@ const dalvikExecutableMapItemTypeParser = promiseCompose(ushortParser, type => {
         }
     }
 });
-const dalvikExecutableMapItemParser = promiseCompose(createTupleParser([
-    dalvikExecutableMapItemTypeParser,
-    ushortParser,
-    uintParser,
-    uintParser,
-]), ([type, _unused, size, offset]) => ({ type, size, offset }));
+const dalvikExecutableMapItemParser = createObjectParser({
+    type: dalvikExecutableMapItemTypeParser,
+    _unused: ushortParser,
+    size: uintParser,
+    offset: uintParser,
+});
 const dalvikExecutableMapListParser = parserCreatorCompose(() => uintParser, size => createQuantifierParser(dalvikExecutableMapItemParser, size))();
 setParserName(dalvikExecutableMapListParser, 'dalvikExecutableMapListParser');
 const createDalvikExecutableMapListParser = (mapOffset) => {
@@ -1358,29 +1355,49 @@ link, }) => {
     ]);
     for (const [offset, codeItem] of codeItemByOffset) {
         const debugInfo = debugInfoByOffset.get(codeItem.debugInfoOffset);
+        // Build code unit to instruction index mapping for address conversion
+        const rawInstructions = codeItem.instructions;
+        const codeUnitToIndexMap = Array.isArray(rawInstructions) ? buildCodeUnitToIndexMap(rawInstructions) : undefined;
+        // Convert branch offsets from code units to instruction offsets
+        // Tier 1 (CodeUnit) -> Tier 2 (InstructionIndex) -> Tier 3 (plain numbers)
+        const convertedInstructions = (Array.isArray(rawInstructions) && codeUnitToIndexMap)
+            ? unwrapBranchOffsets(convertBranchOffsetsToInstructionOffsets(rawInstructions))
+            : codeItem.instructions;
         codeByOffset.set(offset, {
             registersSize: codeItem.registersSize,
             insSize: codeItem.insSize,
             outsSize: codeItem.outsSize,
             debugInfo,
-            instructions: codeItem.instructions,
+            instructions: convertedInstructions,
             tries: codeItem.tryItems.map(tryItem => {
                 const handler_ = codeItem.handlers.get(tryItem.handlerOffset);
                 invariant(handler_, 'Handler must be there. Handler offset: %s', tryItem.handlerOffset);
+                // Convert handler addresses from code units to instruction indices (unwrapped for Tier 3)
                 const handler = {
                     handlers: handler_.handlers.map(encodedHandler => {
                         const type = types.at(encodedHandler.typeIndex);
                         invariant(type, 'Type must be there. Type id: %s', encodedHandler.typeIndex);
                         return {
                             type,
-                            address: encodedHandler.address,
+                            handlerInstructionIndex: codeUnitToIndexMap
+                                ? isoInstructionIndex.unwrap(codeUnitToInstructionIndex(isoCodeUnit.wrap(encodedHandler.address), codeUnitToIndexMap))
+                                : encodedHandler.address,
                         };
                     }),
-                    catchAllAddress: handler_.catchAllAddress,
+                    catchAllInstructionIndex: (handler_.catchAllAddress !== undefined && codeUnitToIndexMap)
+                        ? isoInstructionIndex.unwrap(codeUnitToInstructionIndex(isoCodeUnit.wrap(handler_.catchAllAddress), codeUnitToIndexMap))
+                        : handler_.catchAllAddress,
                 };
+                // Convert try block addresses from code units to instruction indices (unwrapped for Tier 3)
+                const startInstructionIndex = codeUnitToIndexMap
+                    ? isoInstructionIndex.unwrap(codeUnitToInstructionIndex(isoCodeUnit.wrap(tryItem.startAddress), codeUnitToIndexMap))
+                    : tryItem.startAddress;
+                const endInstructionIndex = codeUnitToIndexMap
+                    ? isoInstructionIndex.unwrap(codeUnitToInstructionIndex(isoCodeUnit.wrap(tryItem.startAddress + tryItem.instructionCount), codeUnitToIndexMap))
+                    : tryItem.startAddress + tryItem.instructionCount;
                 return {
-                    startAddress: tryItem.startAddress,
-                    instructionCount: tryItem.instructionCount,
+                    startInstructionIndex,
+                    instructionCount: endInstructionIndex - startInstructionIndex,
                     handler,
                 };
             }),
@@ -1421,7 +1438,7 @@ link, }) => {
         }
         return {
             ...rest,
-            instructions: instructions.map((instruction) => resolveDalvikBytecodeOperation(instruction, resolvers)),
+            instructions: instructions.map((instruction) => resolveRawDalvikBytecodeOperationIndices(instruction, resolvers)),
         };
     }
     for (const [offset, classDataItem] of classDataItemByOffset) {
@@ -1735,10 +1752,8 @@ link, }) => {
         if (classDef.annotations?.parameterAnnotations && classDef.classData) {
             const allMethods = [...(classDef.classData.directMethods ?? []), ...(classDef.classData.virtualMethods ?? [])];
             classDef.annotations.parameterAnnotations.sort((a, b) => {
-                const indexA = allMethods.findIndex(m => m.method.name === a.method.name &&
-                    m.method.prototype.shorty === a.method.prototype.shorty);
-                const indexB = allMethods.findIndex(m => m.method.name === b.method.name &&
-                    m.method.prototype.shorty === b.method.prototype.shorty);
+                const indexA = allMethods.findIndex(m => dalvikExecutableMethodEquals(m.method, a.method));
+                const indexB = allMethods.findIndex(m => dalvikExecutableMethodEquals(m.method, b.method));
                 return indexA - indexB;
             });
         }
@@ -1748,8 +1763,12 @@ link, }) => {
         link,
     };
 }))();
+// The factory creates a parser that outputs RawDalvikBytecode, but the parser internally transforms
+// instructions via unwrapBranchOffsets(convertBranchOffsetsToInstructionOffsets(...)) and
+// resolveRawDalvikBytecodeOperationIndices to produce DalvikBytecode with plain number indices.
+// The cast is required because TypeScript can't track this internal transformation.
 export const dalvikExecutableParser = createDalvikExecutableParser({
-    createInstructionsParser: createDalvikBytecodeParser,
+    createInstructionsParser: createRawDalvikBytecodeParser,
 });
 setParserName(dalvikExecutableParser, 'dalvikExecutableParser');
 export const dalvikExecutableWithRawInstructionsParser = createDalvikExecutableParser({

package/build/dalvikExecutableParser.test.js

@@ -54,8 +54,10 @@ const dexWithParsedInstructionsMacro = test.macro({
             if (typeof key !== 'string') {
                 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) {
             t.snapshot(actual);
@@ -66,7 +68,26 @@ 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, className, methodName) => providedTitle ?? `method ${className}.${methodName} from ${dexCid}`,
+    async exec(t, dexCid, className, methodName) {
+        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');

package/build/dalvikExecutableParserAgainstSmaliParser.test.js

@@ -148,6 +148,9 @@ const parseAllClassesInDexAgainstSmaliMacro = test.macro({
     },
 });
 const testCasesByCid = {
+    bafkreifycfnx4xf3nlml4qavlyxr6bes66nxsow3iaqjghewfsozoj2h3q: [
+        { smaliFilePath: 'pl/czak/minimal/MainActivity', isolate: true },
+    ],
     bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda: [
         { smaliFilePath: 'androidx/activity/ComponentActivity$1', isolate: true },
         { smaliFilePath: 'androidx/activity/R$id', isolate: true },

package/build/dalvikExecutableUnparser/poolScanners.d.ts

@@ -1,4 +1,4 @@
 import { type DalvikExecutable } from '../dalvikExecutable.js';
-import { type DalvikBytecode } from '../dalvikBytecodeParser.js';
+import { type DalvikBytecodeOperation } from '../dalvikBytecodeParser/addressConversion.js';
 import { type PoolBuilders } from './poolBuilders.js';
-export declare function scanForPoolReferences(dalvikExecutable: DalvikExecutable<DalvikBytecode>, poolBuilders: PoolBuilders): void;
+export declare function scanForPoolReferences(dalvikExecutable: DalvikExecutable<DalvikBytecodeOperation[]>, poolBuilders: PoolBuilders): void;

package/build/dalvikExecutableUnparser/sectionUnparsers.d.ts

@@ -1,6 +1,6 @@
 import { type Unparser } from '../unparser.js';
 import { type DalvikExecutableAccessFlags, type DalvikExecutableClassData, type DalvikExecutableCode, type DalvikExecutableDebugInfo, type DalvikExecutableEncodedValue, type DalvikExecutableField, type DalvikExecutableMethod, type DalvikExecutablePrototype } from '../dalvikExecutable.js';
-import { type DalvikBytecode } from '../dalvikBytecodeParser.js';
+import { type DalvikBytecodeOperation } from '../dalvikBytecodeParser/addressConversion.js';
 import { type PoolBuilders } from './poolBuilders.js';
 import { WriteLater } from '../unparserContext.js';
 export declare function createSectionUnparsers(poolBuilders: PoolBuilders): {
@@ -14,8 +14,8 @@ export declare function createSectionUnparsers(poolBuilders: PoolBuilders): {
     debugInfoUnparser: Unparser<DalvikExecutableDebugInfo, Uint8Array<ArrayBufferLike>>;
     codeItemUnparser: (callback?: (result: {
         debugInfoOffsetWriteLater?: WriteLater<Uint8Array, number>;
-    }) => void) => Unparser<DalvikExecutableCode<DalvikBytecode>, Uint8Array>;
-    classDataUnparser: (codeOffsetMap: Map<DalvikExecutableCode<DalvikBytecode>, number>) => Unparser<DalvikExecutableClassData<DalvikBytecode>, Uint8Array>;
+    }) => void) => Unparser<DalvikExecutableCode<DalvikBytecodeOperation[]>, Uint8Array>;
+    classDataUnparser: (codeOffsetMap: Map<DalvikExecutableCode<DalvikBytecodeOperation[]>, number>) => Unparser<DalvikExecutableClassData<DalvikBytecodeOperation[]>, Uint8Array>;
     accessFlagsToNumber: (accessFlags: DalvikExecutableAccessFlags) => number;
     getStringIndex: (str: string | undefined) => number;
     getTypeIndex: (typeDescriptor: string | undefined) => number;

package/build/dalvikExecutableUnparser/sectionUnparsers.js

@@ -5,7 +5,9 @@ async function* yieldAndCapture(gen) {
     }
     return value;
 }
-import { dalvikBytecodeUnparser } from '../dalvikBytecodeUnparser.js';
+import { rawDalvikBytecodeUnparser } from '../dalvikBytecodeUnparser.js';
+import { buildIndexToCodeUnitMapFromResolved, instructionIndexToCodeUnit, wrapBranchOffsets, convertInstructionOffsetsToBranchOffsets, } from '../dalvikBytecodeParser/addressConversion.js';
+import { isoCodeUnit, isoInstructionIndex } from '../dalvikExecutableParser/typedNumbers.js';
 import { ubyteUnparser, ushortUnparser, uintUnparser } from '../dalvikBytecodeUnparser/formatUnparsers.js';
 import { encodeModifiedUtf8, sleb128Unparser, uleb128p1Unparser, uleb128Unparser } from './utils.js';
 export function createSectionUnparsers(poolBuilders) {
@@ -461,17 +463,26 @@ export function createSectionUnparsers(poolBuilders) {
             if (callback) {
                 callback({ debugInfoOffsetWriteLater });
             }
-            const instructionsSizeInShorts = await calculateInstructionsSize(input.instructions);
+            // Convert branch offsets from instruction offsets back to code units
+            // Tier 3 (plain numbers) -> Tier 2 (InstructionIndex) -> Tier 1 (CodeUnit)
+            const rawInstructions = convertInstructionOffsetsToBranchOffsets(wrapBranchOffsets(input.instructions));
+            const instructionsSizeInShorts = await calculateRawInstructionsSize(rawInstructions);
             yield* uintUnparser(instructionsSizeInShorts, unparserContext);
-            yield* dalvikBytecodeUnparser(input.instructions, unparserContext);
+            yield* rawDalvikBytecodeUnparser(rawInstructions, unparserContext);
             if (input.tries.length > 0 && instructionsSizeInShorts % 2 !== 0) {
                 yield* ushortUnparser(0, unparserContext);
             }
             if (input.tries.length > 0) {
+                // Build index to code unit mapping for address conversion
+                const indexToCodeUnitMap = buildIndexToCodeUnitMapFromResolved(input.instructions);
                 const handlerOffsetWriteLaters = [];
                 for (const tryBlock of input.tries) {
-                    yield* uintUnparser(tryBlock.startAddress, unparserContext);
-                    yield* ushortUnparser(tryBlock.instructionCount, unparserContext);
+                    // Convert instruction indices back to code unit offsets
+                    const startAddressCodeUnit = isoCodeUnit.unwrap(instructionIndexToCodeUnit(isoInstructionIndex.wrap(tryBlock.startInstructionIndex), indexToCodeUnitMap));
+                    const endAddressCodeUnit = isoCodeUnit.unwrap(instructionIndexToCodeUnit(isoInstructionIndex.wrap(tryBlock.startInstructionIndex + tryBlock.instructionCount), indexToCodeUnitMap));
+                    const instructionCountCodeUnits = endAddressCodeUnit - startAddressCodeUnit;
+                    yield* uintUnparser(startAddressCodeUnit, unparserContext);
+                    yield* ushortUnparser(instructionCountCodeUnits, unparserContext);
                     const handlerOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(2));
                     handlerOffsetWriteLaters.push(handlerOffsetWriteLater);
                 }
@@ -482,7 +493,7 @@ export function createSectionUnparsers(poolBuilders) {
                     const handler = tryBlock.handler;
                     const handlerOffset = unparserContext.position - handlersStartOffset;
                     yield* unparserContext.writeEarlier(handlerOffsetWriteLaters[i], ushortUnparser, handlerOffset);
-                    if (handler.catchAllAddress !== undefined) {
+                    if (handler.catchAllInstructionIndex !== undefined) {
                         yield* sleb128Unparser(-handler.handlers.length, unparserContext);
                     }
                     else {
@@ -491,23 +502,27 @@ export function createSectionUnparsers(poolBuilders) {
                     for (const handlerItem of handler.handlers) {
                         const typeIndex = getTypeIndex(handlerItem.type);
                         yield* uleb128Unparser(typeIndex, unparserContext);
-                        yield* uleb128Unparser(handlerItem.address, unparserContext);
+                        // Convert handler address from instruction index to code unit offset
+                        const handlerAddressCodeUnit = isoCodeUnit.unwrap(instructionIndexToCodeUnit(isoInstructionIndex.wrap(handlerItem.handlerInstructionIndex), indexToCodeUnitMap));
+                        yield* uleb128Unparser(handlerAddressCodeUnit, unparserContext);
                     }
-                    if (handler.catchAllAddress !== undefined) {
-                        yield* uleb128Unparser(handler.catchAllAddress, unparserContext);
+                    if (handler.catchAllInstructionIndex !== undefined) {
+                        // Convert catchAllInstructionIndex from instruction index to code unit offset
+                        const catchAllAddressCodeUnit = isoCodeUnit.unwrap(instructionIndexToCodeUnit(isoInstructionIndex.wrap(handler.catchAllInstructionIndex), indexToCodeUnitMap));
+                        yield* uleb128Unparser(catchAllAddressCodeUnit, unparserContext);
                     }
                 }
             }
         };
     };
-    async function calculateInstructionsSize(instructions) {
+    async function calculateRawInstructionsSize(instructions) {
         let totalSize = 0;
         const mockContext = {
             position: 0,
             writeLater: () => { throw new Error('Not supported'); },
             writeEarlier: () => { throw new Error('Not supported'); },
         };
-        for await (const chunk of dalvikBytecodeUnparser(instructions, mockContext)) {
+        for await (const chunk of rawDalvikBytecodeUnparser(instructions, mockContext)) {
             if (chunk instanceof Uint8Array) {
                 totalSize += chunk.length;
             }

package/build/dalvikExecutableUnparser.d.ts

@@ -1,4 +1,4 @@
 import { type Unparser } from './unparser.js';
 import { type DalvikExecutable } from './dalvikExecutable.js';
-import { type DalvikBytecode } from './dalvikBytecodeParser.js';
-export declare const dalvikExecutableUnparser: Unparser<DalvikExecutable<DalvikBytecode>, Uint8Array>;
+import { type DalvikBytecodeOperation } from './dalvikBytecodeParser/addressConversion.js';
+export declare const dalvikExecutableUnparser: Unparser<DalvikExecutable<DalvikBytecodeOperation[]>, Uint8Array>;

package/build/dalvikExecutableUnparser.test.js

@@ -10,6 +10,7 @@ import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js'
 import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
 const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
 // Use minimal bytecode for testing - simple nop and return-void instructions
+// These operations have no branch offsets, so they work the same in all tiers
 const arbitraryMinimalBytecode = fc.array(fc.oneof(fc.constant({
     operation: 'nop',
 }), fc.constant({
@@ -19,7 +20,7 @@ testProp('dalvikExecutableUnparser roundtrip', [createArbitraryDalvikExecutable(
     // Unparse to bytes
     const unparsedIterable = runUnparser(dalvikExecutableUnparser, dalvikExecutable, uint8ArrayUnparserOutputCompanion);
     const bytes = await uint8ArrayAsyncIterableToUint8Array(unparsedIterable);
-    // Re-parse
+    // Re-parse (parser now outputs Tier 3 directly)
     const reparsed = await runParser(dalvikExecutableParser, bytes, uint8ArrayParserInputCompanion, {
         errorStack: true,
     });

package/build/disjunctionParser.d.ts

@@ -1,3 +1,5 @@
-import { type Parser } from './parser.js';
-import { type DeriveSequenceElement } from './sequence.js';
-export declare const createDisjunctionParser: <Output, Sequence, Element = DeriveSequenceElement<Sequence>>(childParsers: Array<Parser<unknown, Sequence, Element>>) => Parser<Output, Sequence, Element>;
+import { type Parser, type ParserOutput, type ParserSequence } from './parser.js';
+type DisjunctionParserOutput<Parsers extends readonly unknown[]> = ParserOutput<Parsers[number]>;
+type InferSequenceFromParserArray<T extends readonly unknown[]> = ParserSequence<T[number]>;
+export declare function createDisjunctionParser<const Parsers extends readonly Parser<any, any, any>[]>(childParsers: Parsers): Parser<DisjunctionParserOutput<Parsers>, InferSequenceFromParserArray<Parsers>>;
+export {};