@futpib/parser 1.0.4 → 1.0.6

package/src/dalvikExecutableUnparser/sectionUnparsers.ts

@@ -25,8 +25,16 @@ import {
 	isDalvikExecutableField,
 	isDalvikExecutableMethod,
 } from '../dalvikExecutable.js';
-import { type DalvikBytecode } from '../dalvikBytecodeParser.js';
-import { dalvikBytecodeUnparser } from '../dalvikBytecodeUnparser.js';
+import { type RawDalvikBytecodeOperation } from '../dalvikBytecodeParser.js';
+import { rawDalvikBytecodeUnparser } from '../dalvikBytecodeUnparser.js';
+import {
+	type DalvikBytecodeOperation,
+	buildIndexToCodeUnitMapFromResolved,
+	instructionIndexToCodeUnit,
+	wrapBranchOffsets,
+	convertInstructionOffsetsToBranchOffsets,
+} from '../dalvikBytecodeParser/addressConversion.js';
+import { isoCodeUnit, isoInstructionIndex } from '../dalvikExecutableParser/typedNumbers.js';
 import { ubyteUnparser, ushortUnparser, uintUnparser } from '../dalvikBytecodeUnparser/formatUnparsers.js';
 import { type PoolBuilders } from './poolBuilders.js';
 import { WriteLater } from '../unparserContext.js';
@@ -521,7 +529,7 @@ export function createSectionUnparsers(poolBuilders: PoolBuilders) {
 		yield * ubyteUnparser(0x00, unparserContext);
 	};
 
-	const codeItemUnparser = (callback?: (result: { debugInfoOffsetWriteLater?: WriteLater<Uint8Array, number> }) => void): Unparser<DalvikExecutableCode<DalvikBytecode>, Uint8Array> => {
+	const codeItemUnparser = (callback?: (result: { debugInfoOffsetWriteLater?: WriteLater<Uint8Array, number> }) => void): Unparser<DalvikExecutableCode<DalvikBytecodeOperation[]>, Uint8Array> => {
 		return async function * (input, unparserContext) {
 			yield * ushortUnparser(input.registersSize, unparserContext);
 			yield * ushortUnparser(input.insSize, unparserContext);
@@ -540,21 +548,33 @@ export function createSectionUnparsers(poolBuilders: PoolBuilders) {
 				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: Array<WriteLater<Uint8Array, number>> = [];
 
 				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);
 				}
@@ -569,7 +589,7 @@ export function createSectionUnparsers(poolBuilders: PoolBuilders) {
 					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 {
 						yield * sleb128Unparser(handler.handlers.length, unparserContext);
@@ -578,18 +598,22 @@ export function createSectionUnparsers(poolBuilders: 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: DalvikBytecode): Promise<number> {
+	async function calculateRawInstructionsSize(instructions: RawDalvikBytecodeOperation[]): Promise<number> {
 		let totalSize = 0;
 
 		const mockContext: UnparserContext<Uint8Array, number> = {
@@ -598,7 +622,7 @@ export function createSectionUnparsers(poolBuilders: PoolBuilders) {
 			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;
 			}
@@ -607,7 +631,7 @@ export function createSectionUnparsers(poolBuilders: PoolBuilders) {
 		return Math.floor(totalSize / 2);
 	}
 
-	const classDataUnparser = (codeOffsetMap: Map<DalvikExecutableCode<DalvikBytecode>, number>): Unparser<DalvikExecutableClassData<DalvikBytecode>, Uint8Array> => {
+	const classDataUnparser = (codeOffsetMap: Map<DalvikExecutableCode<DalvikBytecodeOperation[]>, number>): Unparser<DalvikExecutableClassData<DalvikBytecodeOperation[]>, Uint8Array> => {
 		return async function * (input, unparserContext) {
 			yield * uleb128Unparser(input.staticFields.length, unparserContext);
 			yield * uleb128Unparser(input.instanceFields.length, unparserContext);

package/src/dalvikExecutableUnparser.test.ts

@@ -8,11 +8,12 @@ import { runUnparser } from './unparser.js';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
 import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
-import { type DalvikBytecodeOperation } from './dalvikBytecodeParser.js';
+import { type DalvikBytecodeOperation } from './dalvikBytecodeParser/addressConversion.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<DalvikBytecodeOperation>({
@@ -37,7 +38,7 @@ testProp(
 		);
 		const bytes = await uint8ArrayAsyncIterableToUint8Array(unparsedIterable);
 
-		// Re-parse
+		// Re-parse (parser now outputs Tier 3 directly)
 		const reparsed = await runParser(
 			dalvikExecutableParser,
 			bytes,

package/src/dalvikExecutableUnparser.ts

@@ -1,6 +1,6 @@
 import { type Unparser } from './unparser.js';
 import { type DalvikExecutable, type DalvikExecutableClassDefinition, type DalvikExecutableCode, type DalvikExecutableDebugInfo, type DalvikExecutableAnnotation, type DalvikExecutableEncodedValue } from './dalvikExecutable.js';
-import { type DalvikBytecode } from './dalvikBytecodeParser.js';
+import { type DalvikBytecodeOperation } from './dalvikBytecodeParser/addressConversion.js';
 import { uintUnparser, ushortUnparser } from './dalvikBytecodeUnparser/formatUnparsers.js';
 import { createPoolBuilders } from './dalvikExecutableUnparser/poolBuilders.js';
 import { scanForPoolReferences } from './dalvikExecutableUnparser/poolScanners.js';
@@ -76,7 +76,7 @@ class SectionTracker {
 	}
 }
 
-export const dalvikExecutableUnparser: Unparser<DalvikExecutable<DalvikBytecode>, Uint8Array> = async function * (input, unparserContext) {
+export const dalvikExecutableUnparser: Unparser<DalvikExecutable<DalvikBytecodeOperation[]>, Uint8Array> = async function * (input, unparserContext) {
 	const poolBuilders = createPoolBuilders();
 
 	scanForPoolReferences(input, poolBuilders);
@@ -263,7 +263,7 @@ export const dalvikExecutableUnparser: Unparser<DalvikExecutable<DalvikBytecode>
 	// Track classDataItem, codeItem, and debugInfoItem for later writing
 	// Collect data to write items grouped by type (required by DEX format)
 	const classDataToWrite: Array<{
-		classDef: DalvikExecutableClassDefinition<DalvikBytecode>;
+		classDef: DalvikExecutableClassDefinition<DalvikBytecodeOperation[]>;
 		classDefItem: {
 			interfacesOffsetWriteLater?: WriteLater<Uint8Array, number>;
 			annotationsOffsetWriteLater?: WriteLater<Uint8Array, number>;
@@ -272,7 +272,7 @@ export const dalvikExecutableUnparser: Unparser<DalvikExecutable<DalvikBytecode>
 		};
 		classIdx: number;
 	}> = [];
-	const codeToWrite: Array<{ code: DalvikExecutableCode<DalvikBytecode> }> = [];
+	const codeToWrite: Array<{ code: DalvikExecutableCode<DalvikBytecodeOperation[]> }> = [];
 	const debugInfoToWrite: Array<{ debugInfo: DalvikExecutableDebugInfo; offsetWriteLater: WriteLater<Uint8Array, number> }> = [];
 
 	// First pass: collect type lists, encoded arrays, and classData/code/debugInfo to write

package/src/disjunctionParser.test-d.ts

@@ -0,0 +1,105 @@
+import { expectAssignable } from 'tsd';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { type Parser, type ParserOutput } from './parser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+
+// Test: basic disjunction of string parsers - output inferred as string
+{
+	const parser = createDisjunctionParser([
+		createExactElementParser('a'),
+		createExactElementParser('b'),
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	expectAssignable<string>(null! as Output);
+	expectAssignable<Output>(null! as string);
+}
+
+// Test: disjunction preserves literal types when parsers have explicit literal output types
+{
+	const parserA: Parser<'a', string> = async () => 'a' as const;
+	const parserB: Parser<'b', string> = async () => 'b' as const;
+
+	const parser = createDisjunctionParser([parserA, parserB]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output should be 'a' | 'b', not string
+	expectAssignable<'a' | 'b'>(null! as Output);
+	expectAssignable<Output>(null! as 'a' | 'b');
+}
+
+// Test: disjunction of parsers with different output types
+{
+	const stringParser: Parser<string, string> = createFixedLengthSequenceParser(3);
+	const numberParser: Parser<number, string> = () => 42;
+
+	const parser = createDisjunctionParser([
+		stringParser,
+		numberParser,
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output should be string | number
+	expectAssignable<string | number>(null! as Output);
+	expectAssignable<Output>(null! as string | number);
+}
+
+// Test: nested disjunctions
+{
+	const inner = createDisjunctionParser([
+		createExactElementParser('a'),
+		createExactElementParser('b'),
+	]);
+
+	const parser = createDisjunctionParser([
+		inner,
+		createExactElementParser('c'),
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	expectAssignable<string>(null! as Output);
+	expectAssignable<Output>(null! as string);
+}
+
+// Test: sequence type inferred from child parsers
+{
+	const parser = createDisjunctionParser([
+		createExactSequenceParser('hello'),
+		createExactSequenceParser('world'),
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Parser should be for string sequences, output is string (widened from literals)
+	expectAssignable<string>(null! as Output);
+}
+
+// Test: single parser in disjunction
+{
+	const parser = createDisjunctionParser([
+		createExactSequenceParser('only'),
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output is string (widened from literal 'only')
+	expectAssignable<string>(null! as Output);
+}
+
+// Test: disjunction of object-producing parsers
+{
+	const parser1: Parser<{ type: 'a'; value: number }, string> = async () => ({ type: 'a', value: 1 });
+	const parser2: Parser<{ type: 'b'; name: string }, string> = async () => ({ type: 'b', name: 'test' });
+
+	const parser = createDisjunctionParser([parser1, parser2]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	expectAssignable<{ type: 'a'; value: number } | { type: 'b'; name: string }>(null! as Output);
+}

package/src/disjunctionParser.ts

@@ -1,39 +1,42 @@
-import { getParserName, setParserName, type Parser } from './parser.js';
+import { getParserName, setParserName, type Parser, type ParserOutput, type ParserSequence } from './parser.js';
 import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 import { promiseSettled } from './promiseSettled.js';
-import { type DeriveSequenceElement } from './sequence.js';
 
-export const createDisjunctionParser = <
-	Output,
-	Sequence,
-	Element = DeriveSequenceElement<Sequence>,
+// Union all output types from an array of parsers
+type DisjunctionParserOutput<Parsers extends readonly unknown[]> = ParserOutput<Parsers[number]>;
+
+// Infer Sequence from parser array
+type InferSequenceFromParserArray<T extends readonly unknown[]> = ParserSequence<T[number]>;
+
+export function createDisjunctionParser<
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const Parsers extends readonly Parser<any, any, any>[],
 >(
-	childParsers: Array<Parser<unknown, Sequence, Element>>,
-): Parser<Output, Sequence, Element> => {
+	childParsers: Parsers,
+): Parser<DisjunctionParserOutput<Parsers>, InferSequenceFromParserArray<Parsers>> {
 	parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
 
-	const disjunctionParser: Parser<Output, Sequence, Element> = async parserContext => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const disjunctionParser: Parser<any, any, any> = async parserContext => {
 		const parserParsingFailedErrors: ParserParsingFailedError[] = [];
 
 		for (const childParser of childParsers) {
-			const childParserContext = parserContext.lookahead({
+			using childParserContext = parserContext.lookahead({
 				debugName: getParserName(childParser, 'anonymousDisjunctionChild'),
 			});
 
-			const childParserResult = await promiseSettled<Output>(childParser(childParserContext) as Promise<Output>);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const childParserResult = await promiseSettled<any>(childParser(childParserContext) as Promise<any>);
 
 			if (childParserResult.status === 'fulfilled') {
 				const successfulParserOutput = childParserResult.value;
 
 				childParserContext.unlookahead();
-				childParserContext.dispose();
 
 				return successfulParserOutput;
 			}
 
-			childParserContext.dispose();
-
 			const error = childParserResult.reason;
 
 			if (isParserParsingFailedError(error)) {
@@ -57,4 +60,4 @@ export const createDisjunctionParser = <
 	].join('');
 
 	return setParserName(disjunctionParser, name);
-};
+}

package/src/elementSwitchParser.test-d.ts

@@ -0,0 +1,74 @@
+import { expectAssignable, expectType } from 'tsd';
+import { createElementSwitchParser } from './elementSwitchParser.js';
+import { type Parser, type ParserOutput } from './parser.js';
+
+// Test: basic element switch with inferred output type
+{
+	const parserA: Parser<'a', string> = async () => 'a' as const;
+	const parserB: Parser<'b', string> = async () => 'b' as const;
+
+	const parser = createElementSwitchParser(
+		new Map<string, typeof parserA | typeof parserB>([
+			['x', parserA],
+			['y', parserB],
+		]),
+	);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output should be 'a' | 'b'
+	expectAssignable<'a' | 'b'>(null! as Output);
+	expectAssignable<Output>(null! as 'a' | 'b');
+}
+
+// Test: element switch with default parser
+{
+	const parserA: Parser<'a', string> = async () => 'a' as const;
+	const defaultParser: Parser<'default', string> = async () => 'default' as const;
+
+	const parser = createElementSwitchParser(
+		new Map([
+			['x', parserA],
+		]),
+		defaultParser,
+	);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output should be 'a' | 'default'
+	expectAssignable<'a' | 'default'>(null! as Output);
+	expectAssignable<Output>(null! as 'a' | 'default');
+}
+
+// Test: element switch with number keys (Uint8Array sequence)
+{
+	const parser1: Parser<{ type: 'one' }, Uint8Array> = async () => ({ type: 'one' });
+	const parser2: Parser<{ type: 'two' }, Uint8Array> = async () => ({ type: 'two' });
+
+	const parser = createElementSwitchParser(
+		new Map<number, typeof parser1 | typeof parser2>([
+			[1, parser1],
+			[2, parser2],
+		]),
+	);
+
+	type Output = ParserOutput<typeof parser>;
+
+	expectAssignable<{ type: 'one' } | { type: 'two' }>(null! as Output);
+}
+
+// Test: element switch without default parser has no 'never' in output
+{
+	const parserA: Parser<string, string> = async () => 'result';
+
+	const parser = createElementSwitchParser(
+		new Map([
+			['key', parserA],
+		]),
+	);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output should just be string, not string | never
+	expectType<string>(null! as Output);
+}

package/src/elementSwitchParser.ts

@@ -0,0 +1,51 @@
+import invariant from "invariant";
+import { getParserName, Parser, ParserOutput, ParserSequence, setParserName } from "./parser.js";
+import { parserImplementationInvariant } from "./parserImplementationInvariant.js";
+
+// Output type: union of child parser outputs and default parser output (if present)
+type ElementSwitchOutput<
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	ChildParser extends Parser<any, any, any>,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	DefaultParser extends Parser<any, any, any> | undefined,
+> = ParserOutput<ChildParser> | (DefaultParser extends undefined ? never : ParserOutput<NonNullable<DefaultParser>>);
+
+export function createElementSwitchParser<
+	Element,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	ChildParser extends Parser<any, any, Element>,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	DefaultParser extends Parser<any, any, Element> | undefined = undefined,
+>(
+	childParsers: Map<Element, ChildParser>,
+	defaultParser?: DefaultParser,
+): Parser<ElementSwitchOutput<ChildParser, DefaultParser>, ParserSequence<ChildParser>, Element> {
+	parserImplementationInvariant(childParsers.size > 0, 'Element switch parser must have at least one child parser.');
+
+	type Output = ElementSwitchOutput<ChildParser, DefaultParser>;
+	type Sequence = ParserSequence<ChildParser>;
+
+	const elementSwitchParser: Parser<Output, Sequence, Element> = async parserContext => {
+		const currentElement = await parserContext.peek(0);
+
+		parserContext.invariant(currentElement !== undefined, 'Unexpected end of input.');
+		invariant(currentElement !== undefined, 'Unexpected end of input.');
+
+		const childParser = childParsers.get(currentElement) ?? defaultParser;
+
+		parserContext.invariant(childParser, `No child parser found for element: ${String(currentElement)}`);
+
+		return childParser!(parserContext) as Promise<Output>;
+	};
+
+	const name = [
+		'elementSwitch(',
+		...Array.from(childParsers.entries()).map(
+			([ element, childParser ]) => `${String(element)}=>${getParserName(childParser, 'anonymousElementSwitchChild')}`,
+		),
+		defaultParser ? `|default=>${getParserName(defaultParser, 'anonymousElementSwitchDefaultChild')}` : '',
+		')',
+	].join('');
+
+	return setParserName(elementSwitchParser, name);
+}

package/src/exactSequenceParser.test-d.ts

@@ -0,0 +1,43 @@
+import { expectType, expectAssignable } from 'tsd';
+import { createExactSequenceParser, createExactSequenceNaiveParser } from './exactSequenceParser.js';
+import { type Parser } from './parser.js';
+
+// Test: string literal output type is preserved, sequence type is string
+{
+	const parser = createExactSequenceParser('foo');
+	expectType<Parser<'foo', string, unknown>>(parser);
+}
+
+// Test: string literal with 'as const' also works
+{
+	const parser = createExactSequenceParser('bar' as const);
+	expectType<Parser<'bar', string, unknown>>(parser);
+}
+
+// Test: plain string variable widens to string
+{
+	const value: string = 'baz';
+	const parser = createExactSequenceParser(value);
+	expectType<Parser<string, string, unknown>>(parser);
+}
+
+// Test: Uint8Array sequence type is preserved
+{
+	const bytes = new Uint8Array([1, 2, 3]);
+	const parser = createExactSequenceParser(bytes);
+	// Output is the specific Uint8Array instance type, Sequence is Uint8Array
+	expectAssignable<Parser<Uint8Array, Uint8Array, unknown>>(parser);
+}
+
+// Test: naive parser has same type behavior
+{
+	const parser = createExactSequenceNaiveParser('hello');
+	expectType<Parser<'hello', string, unknown>>(parser);
+}
+
+// Test: naive parser with Uint8Array
+{
+	const bytes = new Uint8Array([0xff]);
+	const parser = createExactSequenceNaiveParser(bytes);
+	expectAssignable<Parser<Uint8Array, Uint8Array, unknown>>(parser);
+}

package/src/exactSequenceParser.ts

@@ -1,13 +1,17 @@
 import { setParserName, type Parser } from './parser.js';
 import { inspect } from './inspect.js';
 
-export const createExactSequenceNaiveParser = <Sequence>(sequence: Sequence) => {
-	const exactSequenceParser: Parser<Sequence, Sequence, unknown> = async parserContext => {
-		const length = parserContext.length(sequence);
+// Derive the base sequence type from a literal (e.g., 'foo' -> string, Uint8Array -> Uint8Array)
+type DeriveBaseSequence<T> = T extends string ? string : T extends Uint8Array ? Uint8Array : T;
+
+export const createExactSequenceNaiveParser = <const Output>(sequence: Output) => {
+	type Sequence = DeriveBaseSequence<Output>;
+	const exactSequenceParser: Parser<Output, Sequence, unknown> = async parserContext => {
+		const length = parserContext.length(sequence as Sequence);
 
 		for (let index = 0; index < length; index++) {
 			const element = await parserContext.read(0);
-			const expectedElement = parserContext.at(sequence, index);
+			const expectedElement = parserContext.at(sequence as Sequence, index);
 
 			parserContext.invariant(
 				element === expectedElement,
@@ -26,14 +30,15 @@ export const createExactSequenceNaiveParser = <Sequence>(sequence: Sequence) =>
 	return exactSequenceParser;
 };
 
-export const createExactSequenceParser = <Sequence>(expectedSequence: Sequence) => {
-	const exactSequenceParser: Parser<Sequence, Sequence, unknown> = async parserContext => {
-		const length = parserContext.length(expectedSequence);
+export const createExactSequenceParser = <const Output>(expectedSequence: Output) => {
+	type Sequence = DeriveBaseSequence<Output>;
+	const exactSequenceParser: Parser<Output, Sequence, unknown> = async parserContext => {
+		const length = parserContext.length(expectedSequence as Sequence);
 
 		const actualSequence = await parserContext.readSequence(0, length);
 
 		parserContext.invariant(
-			parserContext.equals(actualSequence, expectedSequence),
+			parserContext.equals(actualSequence, expectedSequence as Sequence),
 			'Expected "%s", got "%s"',
 			() => inspect(expectedSequence),
 			() => inspect(actualSequence),

package/src/fetchCid.ts

@@ -1,9 +1,5 @@
 import fsPromises from 'node:fs/promises';
-import path from 'node:path';
-import pMemoize from 'p-memoize';
-import envPaths from 'env-paths';
-
-const paths = envPaths('parser.futpib.github.io');
+import { fetchCid as fetchCidFromIpfs } from '@futpib/fetch-cid';
 
 function readableWebStreamOnFinish<T>(readableWebStream: ReadableStream<T>, onFinish: () => void): ReadableStream<T> {
 	const reader = readableWebStream.getReader();
@@ -34,74 +30,6 @@ function readableWebStreamOnFinish<T>(readableWebStream: ReadableStream<T>, onFi
 	return stream;
 }
 
-class FsCache {
-	private get _basePath() {
-		return path.join(paths.cache, 'fetchCid');
-	}
-
-	private _getKeyPath(key: string) {
-		return path.join(this._basePath, key.replaceAll('/', '_'));
-	}
-
-	async get(key: string): Promise<[ ReadableStream<Uint8Array>, ReadableStream<Uint8Array> ] | undefined> {
-		try {
-			const file = await fsPromises.open(this._getKeyPath(key), 'r');
-
-			const stream = file.readableWebStream() as ReadableStream<Uint8Array>;
-
-			const streamWithClose = readableWebStreamOnFinish(stream, () => {
-				file.close();
-			});
-
-			return [ streamWithClose, undefined as unknown as ReadableStream<Uint8Array> ];
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-				return undefined;
-			}
-
-			throw error;
-		}
-	}
-
-	async has(key: string) {
-		const streams = await this.get(key);
-		try {
-			return streams !== undefined;
-		} finally {
-			for (const stream of streams ?? []) {
-				await stream?.cancel();
-			}
-		}
-	}
-
-	async set(key: string, [ _, value ]: [ ReadableStream<Uint8Array>, ReadableStream<Uint8Array> ]) {
-		await fsPromises.mkdir(this._basePath, {
-			recursive: true,
-		});
-		const file = await fsPromises.open(this._getKeyPath(key), 'w');
-		try {
-			for await (const chunk of value) {
-				await file.write(chunk);
-			}
-		} finally {
-			await file.close();
-		}
-	}
-
-	async delete(key: string) {
-		await fsPromises.unlink(this._getKeyPath(key));
-	}
-}
-
-async function reallyFetchCid(cid: string): Promise<[ ReadableStream<Uint8Array>, ReadableStream<Uint8Array> ]> {
-	const response = await fetch('https://ipfs.io/ipfs/' + cid);
-	return response.body!.tee();
-}
-
-const cachedReallyFetchCid = pMemoize(reallyFetchCid, {
-	cache: new FsCache(),
-});
-
 export async function fetchCid(cidOrPath: string): Promise<AsyncIterable<Uint8Array>> {
 	if (cidOrPath.includes('/')) {
 		const file = await fsPromises.open(cidOrPath, 'r');
@@ -115,7 +43,5 @@ export async function fetchCid(cidOrPath: string): Promise<AsyncIterable<Uint8Ar
 		return streamWithClose;
 	}
 
-	const [ readable, unused ] = await cachedReallyFetchCid(cidOrPath);
-	await unused?.cancel();
-	return readable;
+	return fetchCidFromIpfs(cidOrPath);
 }