refactor: always break on first error

lib/mod.test.ts

···
 	const result = p.tryDecode(Message, invalidData);
 	assert(!result.ok);
 
-	assertEquals(result.issues.length, 3); // field1, field2, and field3 have wrong wire types
-
-	const codes = result.issues.map((issue) => issue.code);
-	assert(codes.every((code) => code === 'invalid_wire'));
-
-	const fields = result.issues.map((issue) => issue.path[0]);
-	assertArrayIncludes(fields, ['field1', 'field2', 'field3']);
-
-	assertStringIncludes(result.message, '+2 other issue(s)');
+	assertEquals(result.message, 'invalid_wire at .field1 (expected wire type 2)');
 });
 
 Deno.test('missing required fields during decoding', () => {
 	const Message = p.message({
 		required1: p.string(),
-		required2: p.int32(),
 		optional: p.optional(p.string()),
 	}, {
 		required1: 1,
···
 
 	const result = p.tryDecode(Message, encoded);
 	assert(!result.ok);
-
-	const issues = result.issues;
-	assertEquals(issues.length, 2);
-
-	const missingCodes = issues.map((issue) => issue.code);
-	assertArrayIncludes(missingCodes, ['missing_value', 'missing_value']);
-
-	const missingKeys = issues.map((issue) => issue.path.join('.'));
-	assertArrayIncludes(missingKeys, ['required1', 'required2']);
+	assertEquals(result.message, 'missing_value at .required1 (required field is missing)');
 });
 
 Deno.test('empty buffer handling', () => {
···
 	const result = p.tryDecode(Message, truncatedBuffer);
 
 	assert(!result.ok);
-	assertEquals(result.message, `unexpected_eof at .text (unexpected end of input) (+1 other issue(s))`);
+	assertEquals(result.message, `unexpected_eof at .text (unexpected end of input)`);
 });
 
 Deno.test('buffer underrun during varint reading', () => {
···
 	const result = p.tryDecode(Message, incompleteVarint);
 
 	assert(!result.ok);
-	assertEquals(result.message, `unexpected_eof at .value (unexpected end of input) (+1 other issue(s))`);
+	assertEquals(result.message, `unexpected_eof at .value (unexpected end of input)`);
 });
 
 // #endregion

lib/mod.ts

···
 
 type IssueTree =
 	| IssueLeaf
-	| { ok: false; code: 'prepend'; key: Key; tree: IssueTree }
-	| { ok: false; code: 'join'; left: IssueTree; right: IssueTree };
+	| { ok: false; code: 'prepend'; key: Key; tree: IssueTree };
 
 export type Issue = Readonly<
 	| { code: 'unexpected_eof'; path: Key[] }
···
 const UINT64_RANGE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_range', type: 'uint64' };
 
 // #__NO_SIDE_EFFECTS__
-const joinIssues = (left: IssueTree | undefined, right: IssueTree): IssueTree => {
-	return left ? { ok: false, code: 'join', left, right } : right;
-};
-
-// #__NO_SIDE_EFFECTS__
 const prependPath = (key: Key, tree: IssueTree): IssueTree => {
 	return { ok: false, code: 'prepend', key, tree };
 };
···
 const collectIssues = (tree: IssueTree, path: Key[] = [], issues: Issue[] = []): Issue[] => {
 	for (;;) {
 		switch (tree.code) {
-			case 'join': {
-				collectIssues(tree.left, path.slice(), issues);
-				tree = tree.right;
-				continue;
-			}
 			case 'prepend': {
 				path.push(tree.key);
 				tree = tree.tree;
···
 	}
 };
 
-const countIssues = (tree: IssueTree): number => {
-	let count = 0;
-	for (;;) {
-		switch (tree.code) {
-			case 'join': {
-				count += countIssues(tree.left);
-				tree = tree.right;
-				continue;
-			}
-			case 'prepend': {
-				tree = tree.tree;
-				continue;
-			}
-			default: {
-				return count + 1;
-			}
-		}
-	}
-};
-
 const formatIssueTree = (tree: IssueTree): string => {
 	let path = '';
-	let count = 0;
 	for (;;) {
 		switch (tree.code) {
-			case 'join': {
-				count += countIssues(tree.right);
-				tree = tree.left;
-				continue;
-			}
 			case 'prepend': {
 				path += `.${tree.key}`;
 				tree = tree.tree;
···
 			break;
 	}
 
-	let msg = `${tree.code} at ${path || '.'} (${message})`;
-	if (count > 0) {
-		msg += ` (+${count} other issue(s))`;
-	}
-
-	return msg;
+	return `${tree.code} at ${path || '.'} (${message})`;
 };
 
 // #endregion
···
 ): Result<InferOutput<TSchema>> => {
 	const state = createDecoderState(buffer);
 
-	const result = schema['~~decode'](state, FLAG_EMPTY);
+	const result = schema['~~decode'](state);
 
 	if (result.ok) {
 		return result as Ok<InferOutput<TSchema>>;
···
 ): InferOutput<TSchema> => {
 	const state = createDecoderState(buffer);
 
-	const result = schema['~~decode'](state, FLAG_EMPTY);
+	const result = schema['~~decode'](state);
 
 	if (result.ok) {
 		return result.value as InferOutput<TSchema>;
···
 declare const kObjectType: unique symbol;
 type kObjectType = typeof kObjectType;
 
-// None set
-export const FLAG_EMPTY = 0;
-// Don't continue validation if an error is encountered
-export const FLAG_ABORT_EARLY = 1 << 0;
-
 type RawResult<T = unknown> = Ok<T> | IssueTree;
 
-type Decoder = (this: void, state: DecoderState, flags: number) => RawResult;
+type Decoder = (this: void, state: DecoderState) => RawResult;
 
 type Encoder = (this: void, state: EncoderState, input: unknown) => IssueTree | void;
 
···
 	kind: 'schema',
 	type: 'string',
 	wire: 2,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const length = readVarint(state);
 		if (!length.ok) {
 			return length;
···
 	kind: 'schema',
 	type: 'bytes',
 	wire: 2,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const length = readVarint(state);
 		if (!length.ok) {
 			return length;
···
 	kind: 'schema',
 	type: 'boolean',
 	wire: 0,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const result = readVarint(state);
 		if (!result.ok) {
 			return result;
···
 	kind: 'schema',
 	type: 'double',
 	wire: 1,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const view = getDataView(state);
 		const value = view.getFloat64(state.p, true);
 
···
 	kind: 'schema',
 	type: 'float',
 	wire: 5,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const view = getDataView(state);
 		const value = view.getFloat32(state.p, true);
 
···
 	kind: 'schema',
 	type: 'int32',
 	wire: 0,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const result = readVarint(state);
 		if (!result.ok) {
 			return result;
···
 	kind: 'schema',
 	type: 'int64',
 	wire: 0,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const buf = state.b;
 		let pos = state.p;
 
···
 	kind: 'schema',
 	type: 'uint32',
 	wire: 0,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const result = readVarint(state);
 		if (!result.ok) {
 			return result;
···
 	kind: 'schema',
 	type: 'uint64',
 	wire: 0,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const buf = state.b;
 		let pos = state.p;
 
···
 	kind: 'schema',
 	type: 'sint32',
 	wire: 0,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const result = readVarint(state);
 		if (!result.ok) {
 			return result;
···
 	kind: 'schema',
 	type: 'sint64',
 	wire: 0,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const buf = state.b;
 		let pos = state.p;
 
···
 	kind: 'schema',
 	type: 'fixed32',
 	wire: 5,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const view = getDataView(state);
 		const value = view.getUint32(state.p, true);
 
···
 	kind: 'schema',
 	type: 'fixed64',
 	wire: 1,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const view = getDataView(state);
 
 		// Read as two 32-bit values and combine into a BigInt
···
 	kind: 'schema',
 	type: 'sfixed32',
 	wire: 5,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const view = getDataView(state);
 		const value = view.getInt32(state.p, true);
 
···
 	kind: 'schema',
 	type: 'sfixed64',
 	wire: 1,
-	'~decode'(state, _flags) {
+	'~decode'(state) {
 		const view = getDataView(state);
 
 		// Read as two 32-bit values and combine into a BigInt
···
 		get '~decode'() {
 			const shape = resolvedShape.value;
 
-			const decoder: Decoder = (state, flags) => {
+			const decoder: Decoder = (state) => {
 				const length = readVarint(state);
 				if (!length.ok) {
 					return length;
···
 				let issues: IssueTree | undefined;
 
 				while (children.p < length.value) {
-					const r = shape['~decode'](children, flags);
+					const r = shape['~decode'](children);
 
-					if (r.ok) {
-						array.push(r.value);
-					} else {
-						issues = joinIssues(issues, prependPath(idx, r));
-
-						if (flags & FLAG_ABORT_EARLY) {
-							return issues;
-						}
+					if (!r.ok) {
+						return prependPath(idx, r);
 					}
 
+					array.push(r.value);
 					idx++;
 				}
 
···
 		wrapped: wrapped,
 		default: defaultValue,
 		wire: wrapped.wire,
-		'~decode'(state, flags) {
-			return wrapped['~decode'](state, flags);
+		'~decode'(state) {
+			return wrapped['~decode'](state);
 		},
 		'~encode'(state, input) {
 			return wrapped['~encode'](state, input);
···
 			const shape = resolvedEntries.value;
 			const len = Object.keys(shape).length;
 
-			const decoder: Decoder = (state, flags) => {
+			const decoder: Decoder = (state) => {
 				let seenBits: BitSet = 0;
 				let seenCount = 0;
 
···
 				while (state.p < end) {
 					const prelude = readVarint(state);
 					if (!prelude.ok) {
-						issues = joinIssues(issues, prelude);
-						if (flags & FLAG_ABORT_EARLY) {
-							return issues;
-						}
-
-						break;
+						return prelude;
 					}
 
 					const magic = prelude.value;
···
 					if (!entry) {
 						const result = skipField(state, wire);
 						if (!result.ok) {
-							issues = joinIssues(issues, result);
-							if (flags & FLAG_ABORT_EARLY) {
-								return issues;
-							}
-
-							break;
+							return result;
 						}
+
 						continue;
 					}
 
···
 
 					// It doesn't match with our wire, file an issue
 					if (entry.wire !== wire) {
-						issues = joinIssues(issues, entry.wireIssue);
-						if (flags & FLAG_ABORT_EARLY) {
-							return issues;
-						}
-
-						const skip = skipField(state, wire);
-						if (!skip.ok) {
-							issues = joinIssues(issues, prependPath(entry.key, skip));
-							if (flags & FLAG_ABORT_EARLY) {
-								return issues;
-							}
-
-							break;
-						}
-
-						continue;
+						return entry.wireIssue;
 					}
 
 					// Decode the value
-					const result = entry.schema['~decode'](state, flags);
+					const result = entry.schema['~decode'](state);
 
 					// Failed to decode, file an issue
 					if (!result.ok) {
-						issues = joinIssues(issues, prependPath(entry.key, result));
-						if (flags & FLAG_ABORT_EARLY) {
-							return issues;
-						}
-
-						continue;
+						return prependPath(entry.key, result);
 					}
 
 					/*#__INLINE__*/ set(obj, entry.key, result.value);
···
 									/*#__INLINE__*/ set(obj, entry.key, defaultValue);
 								}
 							} else {
-								issues = joinIssues(issues, entry.missingIssue);
-
-								if (flags & FLAG_ABORT_EARLY) {
-									return issues;
-								}
+								return entry.missingIssue;
 							}
 						}
 					}
···
 		get '~decode'() {
 			const raw = this['~~decode'];
 
-			const decoder: Decoder = (state, flags) => {
+			const decoder: Decoder = (state) => {
 				const length = readVarint(state);
 				if (!length.ok) {
 					return length;
···
 					v: null,
 				};
 
-				return raw(child, flags);
+				return raw(child);
 			};
 
 			return lazyProperty(this, '~decode', decoder);
···
 		key,
 		value,
 		get '~decode'() {
-			const decoder: Decoder = (state, flags) => {
-				const result = Schema['~decode'](state, flags);
+			const decoder: Decoder = (state) => {
+				const result = Schema['~decode'](state);
 				if (!result.ok) {
 					return result;
 				}