@optique/core 1.2.8 → 1.2.9

package/dist/constructs.cjs

@@ -8,6 +8,7 @@ const require_internal_dependency = require('./internal/dependency.cjs');
 const require_dependency_runtime = require('./dependency-runtime.cjs');
 const require_internal_parser = require('./internal/parser.cjs');
 const require_annotation_state = require('./annotation-state.cjs');
+const require_passthrough = require('./internal/passthrough.cjs');
 const require_command_alias = require('./internal/command-alias.cjs');
 const require_execution_context = require('./execution-context.cjs');
 const require_phase2_seed = require('./phase2-seed.cjs');
@@ -98,6 +99,63 @@ function sharedBufferLeadingNames(parsers) {
 	return names.size === 0 ? EMPTY_LEADING_NAMES : names;
 }
 /**
+* Defers capture until a known option at an equal or higher lane priority
+* has been tried.
+* Other siblings retain their relative order, and explicit priorities win.
+*/
+function orderBeforePassThrough(pairs, context, getParser, getState, passThroughParsers) {
+	const token = context.buffer[0];
+	if (passThroughParsers.size === 0 || context.optionsTerminated || token == null || token === "--" || !/^[-/+]/.test(token)) return pairs;
+	const matches = new Map(pairs.map((pair) => [pair, require_passthrough.getOptionMatch(getParser(pair), getState(pair), token)]));
+	const normalizedOptions = /* @__PURE__ */ new Map();
+	const captures = new Map(pairs.flatMap((pair) => {
+		if (!passThroughParsers.has(getParser(pair))) return [];
+		const priority = require_passthrough.getPassThroughPriority(getParser(pair), getState(pair), token);
+		const match = matches.get(pair);
+		if (match != null && (priority == null || match.priority >= priority)) {
+			const unfiltered = require_passthrough.getPassThroughPriority(getParser(pair), getState(pair));
+			if (priority == null || unfiltered != null && unfiltered > match.priority) normalizedOptions.set(pair, match.priority);
+			return [];
+		}
+		return priority == null ? [] : [[pair, priority]];
+	}));
+	const matching = pairs.filter((pair) => !captures.has(pair)).flatMap((pair) => {
+		const match = matches.get(pair);
+		return match == null ? [] : [match];
+	});
+	const orderedCaptures = [...captures].sort((a, b) => b[1] - a[1]);
+	if (matching.length === 0) {
+		let captureIndex = 0;
+		return pairs.map((pair) => captures.has(pair) ? orderedCaptures[captureIndex++][0] : pair);
+	}
+	const matchingPriority = Math.max(...matching.map((match) => match.priority));
+	const ordinary = pairs.filter((pair) => !captures.has(pair) && !normalizedOptions.has(pair));
+	const positions = new Map(pairs.map((pair, index) => [pair, index]));
+	for (const [pair, priority] of [...normalizedOptions].sort((a, b) => b[1] - a[1])) {
+		let insertion = ordinary.findIndex((candidate) => {
+			const match = matches.get(candidate);
+			return match != null && (match.priority < priority || match.priority === priority && positions.get(pair) < positions.get(candidate));
+		});
+		if (insertion < 0) {
+			const lastMatch = ordinary.findLastIndex((candidate) => matches.get(candidate) != null);
+			insertion = lastMatch >= 0 ? lastMatch + 1 : ordinary.findIndex((candidate) => positions.get(candidate) > positions.get(pair));
+			if (insertion < 0) insertion = ordinary.length;
+		}
+		ordinary.splice(insertion, 0, pair);
+	}
+	const first = ordinary.findIndex((pair) => matches.get(pair) != null);
+	const last = ordinary.findLastIndex((pair) => matches.get(pair) != null);
+	const before = orderedCaptures.filter(([, priority]) => priority > matchingPriority).map(([pair]) => pair);
+	const after = orderedCaptures.filter(([, priority]) => priority <= matchingPriority).map(([pair]) => pair);
+	return [
+		...ordinary.slice(0, first),
+		...before,
+		...ordinary.slice(first, last + 1),
+		...after,
+		...ordinary.slice(last + 1)
+	];
+}
+/**
 * Internal symbol for exposing field-level parser pairs from `object()`
 * and `merge()` parsers.  This allows `merge()` to pre-complete dependency
 * source fields from child parsers before resolving deferred states.
@@ -599,6 +657,7 @@ function preserveExclusiveStateAfterOptionsTerminator(context, result) {
 		success: true,
 		next: {
 			...context,
+			...require_passthrough.getPassThroughFailureHint(result.next),
 			buffer: result.next.buffer,
 			optionsTerminated: true,
 			state: context.state,
@@ -887,6 +946,7 @@ function or(...args) {
 							success: true,
 							next: {
 								...context,
+								...require_passthrough.getPassThroughFailureHint(result.next),
 								buffer: result.next.buffer,
 								optionsTerminated: result.next.optionsTerminated,
 								state: createExclusiveState(context.state, i, parser, result),
@@ -923,6 +983,7 @@ function or(...args) {
 						success: true,
 						next: {
 							...context,
+							...require_passthrough.getPassThroughFailureHint(replayedResult.next),
 							buffer: replayedResult.next.buffer,
 							optionsTerminated: replayedResult.next.optionsTerminated,
 							state: createExclusiveState(context.state, i, parser, {
@@ -942,6 +1003,7 @@ function or(...args) {
 					success: true,
 					next: {
 						...context,
+						...require_passthrough.getPassThroughFailureHint(result.next),
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: createExclusiveState(context.state, i, parser, result),
@@ -986,6 +1048,7 @@ function or(...args) {
 					provisional: true,
 					next: {
 						...context,
+						...require_passthrough.getPassThroughFailureHint(provisionalConsuming.result.next),
 						buffer: provisionalConsuming.result.next.buffer,
 						optionsTerminated: provisionalConsuming.result.next.optionsTerminated,
 						state: createExclusiveState(context.state, provisionalConsuming.index, provisionalConsuming.parser, provisionalConsuming.result),
@@ -1020,6 +1083,7 @@ function or(...args) {
 						provisional: true,
 						next: {
 							...context,
+							...require_passthrough.getPassThroughFailureHint(replayedResult.next),
 							buffer: replayedResult.next.buffer,
 							optionsTerminated: replayedResult.next.optionsTerminated,
 							state: createExclusiveState(context.state, provisionalConsuming.index, provisionalConsuming.parser, {
@@ -1091,6 +1155,7 @@ function or(...args) {
 							success: true,
 							next: {
 								...context,
+								...require_passthrough.getPassThroughFailureHint(result.next),
 								buffer: result.next.buffer,
 								optionsTerminated: result.next.optionsTerminated,
 								state: createExclusiveState(context.state, i, parser, result),
@@ -1129,6 +1194,7 @@ function or(...args) {
 						success: true,
 						next: {
 							...context,
+							...require_passthrough.getPassThroughFailureHint(replayedResult.next),
 							buffer: replayedResult.next.buffer,
 							optionsTerminated: replayedResult.next.optionsTerminated,
 							state: createExclusiveState(context.state, i, parser, {
@@ -1148,6 +1214,7 @@ function or(...args) {
 					success: true,
 					next: {
 						...context,
+						...require_passthrough.getPassThroughFailureHint(result.next),
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: createExclusiveState(context.state, i, parser, result),
@@ -1192,6 +1259,7 @@ function or(...args) {
 					provisional: true,
 					next: {
 						...context,
+						...require_passthrough.getPassThroughFailureHint(provisionalConsuming.result.next),
 						buffer: provisionalConsuming.result.next.buffer,
 						optionsTerminated: provisionalConsuming.result.next.optionsTerminated,
 						state: createExclusiveState(context.state, provisionalConsuming.index, provisionalConsuming.parser, provisionalConsuming.result),
@@ -1226,6 +1294,7 @@ function or(...args) {
 						provisional: true,
 						next: {
 							...context,
+							...require_passthrough.getPassThroughFailureHint(replayedResult.next),
 							buffer: replayedResult.next.buffer,
 							optionsTerminated: replayedResult.next.optionsTerminated,
 							state: createExclusiveState(context.state, provisionalConsuming.index, provisionalConsuming.parser, {
@@ -1311,6 +1380,14 @@ function or(...args) {
 	const singleDependencyMetadata = composeExclusiveDependencyMetadata(parsers);
 	if (singleDependencyMetadata != null) singleResult.dependencyMetadata = singleDependencyMetadata;
 	require_internal_parser.defineInheritedAnnotationParser(singleResult);
+	require_passthrough.defineOptionMatch(singleResult, (state, token) => require_passthrough.combineOptionMatches(parsers.map((parser, index) => {
+		const active = normalizeExclusiveState(state);
+		return require_passthrough.getOptionMatch(parser, active?.[0] === index && active[1].success ? active[1].next.state : parser.initialState, token);
+	})));
+	require_passthrough.definePassThroughPriority(singleResult, parsers, (state, token) => {
+		const active = normalizeExclusiveState(state);
+		return require_passthrough.combinePassThroughPriorities(parsers.map((parser, index) => require_passthrough.getPassThroughPriority(parser, active?.[0] === index && active[1].success ? active[1].next.state : parser.initialState, token)));
+	});
 	return require_modifiers.fluent(singleResult);
 }
 /**
@@ -1345,24 +1422,27 @@ function createLongestMatch(...args) {
 			return createUnexpectedInputErrorWithScopedSuggestions(defaultMsg, token, parsers, options?.errors?.suggestions);
 		})()
 	});
-	const commitLongestMatch = (context, match, optionsTerminatorResult) => {
+	const commitLongestMatch = (context, match, optionsTerminatorResult, consumingFailure) => {
 		const selectedResult = optionsTerminatorResult == null ? match.result : {
 			...match.result,
 			next: {
 				...match.result.next,
+				...require_passthrough.getPassThroughFailureHint(optionsTerminatorResult.next),
 				buffer: optionsTerminatorResult.next.buffer,
 				optionsTerminated: true
 			},
 			consumed: [...optionsTerminatorResult.consumed, ...match.result.consumed]
 		};
+		const next = selectedResult.consumed.length === 0 ? require_passthrough.withPassThroughFailure(selectedResult.next, consumingFailure) : selectedResult.next;
 		const parser = parsers[match.index];
-		const mergedExec = require_execution_context.mergeChildExec(context.exec, selectedResult.next.exec);
+		const mergedExec = require_execution_context.mergeChildExec(context.exec, next.exec);
 		return {
 			success: true,
 			next: {
 				...context,
-				buffer: selectedResult.next.buffer,
-				optionsTerminated: selectedResult.next.optionsTerminated,
+				...require_passthrough.getPassThroughFailureHint(next),
+				buffer: next.buffer,
+				optionsTerminated: next.optionsTerminated,
 				state: createExclusiveState(context.state, match.index, parser, selectedResult),
 				...mergedExec != null ? {
 					exec: mergedExec,
@@ -1397,6 +1477,7 @@ function createLongestMatch(...args) {
 		let bestMatch = null;
 		const optionsTerminatorMatches = [];
 		let error = getInitialError(context);
+		let consumingFailure;
 		const activeState = normalizeExclusiveState(context.state);
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
@@ -1412,6 +1493,7 @@ function createLongestMatch(...args) {
 				continue;
 			}
 			if (result.success) {
+				consumingFailure = require_passthrough.retainConsumingFailureHint(consumingFailure, context, result.next);
 				const consumed = context.buffer.length - result.next.buffer.length;
 				const bestIsProvisional = bestMatch != null && bestMatch.result.success && !!bestMatch.result.provisional;
 				if (bestMatch === null || consumed > bestMatch.consumed || consumed === bestMatch.consumed && bestIsProvisional && !result.provisional) bestMatch = {
@@ -1419,11 +1501,15 @@ function createLongestMatch(...args) {
 					result,
 					consumed
 				};
-			} else if (error.consumed < result.consumed) error = result;
+			} else {
+				const match = require_passthrough.getOptionMatch(parser, childContext.state, context.buffer[0]);
+				if (result.consumed > 0 && match != null) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, match.priority);
+				if (error.consumed < result.consumed) error = result;
+			}
 		}
 		const optionsTerminatorResolution = resolveLongestMatchOptionsTerminator(context, bestMatch, optionsTerminatorMatches);
 		if (optionsTerminatorResolution != null) return optionsTerminatorResolution;
-		if (bestMatch != null) return commitLongestMatch(context, bestMatch);
+		if (bestMatch != null) return commitLongestMatch(context, bestMatch, void 0, consumingFailure);
 		return {
 			...error,
 			success: false
@@ -1433,6 +1519,7 @@ function createLongestMatch(...args) {
 		let bestMatch = null;
 		const optionsTerminatorMatches = [];
 		let error = getInitialError(context);
+		let consumingFailure;
 		const activeState = normalizeExclusiveState(context.state);
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
@@ -1449,6 +1536,7 @@ function createLongestMatch(...args) {
 				continue;
 			}
 			if (result.success) {
+				consumingFailure = require_passthrough.retainConsumingFailureHint(consumingFailure, context, result.next);
 				const consumed = context.buffer.length - result.next.buffer.length;
 				const bestIsProvisional = bestMatch != null && bestMatch.result.success && !!bestMatch.result.provisional;
 				if (bestMatch === null || consumed > bestMatch.consumed || consumed === bestMatch.consumed && bestIsProvisional && !result.provisional) bestMatch = {
@@ -1456,11 +1544,15 @@ function createLongestMatch(...args) {
 					result,
 					consumed
 				};
-			} else if (error.consumed < result.consumed) error = result;
+			} else {
+				const match = require_passthrough.getOptionMatch(parser, childContext.state, context.buffer[0]);
+				if (result.consumed > 0 && match != null) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, match.priority);
+				if (error.consumed < result.consumed) error = result;
+			}
 		}
 		const optionsTerminatorResolution = resolveLongestMatchOptionsTerminator(context, bestMatch, optionsTerminatorMatches);
 		if (optionsTerminatorResolution != null) return optionsTerminatorResolution;
-		if (bestMatch != null) return commitLongestMatch(context, bestMatch);
+		if (bestMatch != null) return commitLongestMatch(context, bestMatch, void 0, consumingFailure);
 		return {
 			...error,
 			success: false
@@ -1526,6 +1618,14 @@ function createLongestMatch(...args) {
 	const multiDependencyMetadata = composeExclusiveDependencyMetadata(parsers);
 	if (multiDependencyMetadata != null) multiResult.dependencyMetadata = multiDependencyMetadata;
 	require_internal_parser.defineInheritedAnnotationParser(multiResult);
+	require_passthrough.defineOptionMatch(multiResult, (state, token) => require_passthrough.combineOptionMatches(parsers.map((parser, index) => {
+		const active = normalizeExclusiveState(state);
+		return require_passthrough.getOptionMatch(parser, active?.[0] === index && active[1].success ? active[1].next.state : parser.initialState, token);
+	})));
+	require_passthrough.definePassThroughPriority(multiResult, parsers, (state, token) => {
+		const active = normalizeExclusiveState(state);
+		return require_passthrough.combinePassThroughPriorities(parsers.map((parser, index) => require_passthrough.getPassThroughPriority(parser, active?.[0] === index && active[1].success ? active[1].next.state : parser.initialState, token)));
+	});
 	return require_modifiers.fluent(multiResult);
 }
 /**
@@ -1916,6 +2016,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	const parserKeys = Reflect.ownKeys(parsers);
 	const parserPairs = parserKeys.map((k) => [k, parsers[k]]);
 	parserPairs.sort(([_, parserA], [__, parserB]) => parserB.priority - parserA.priority);
+	const passThroughParsers = new Set(parserPairs.map(([, parser]) => parser).filter((parser) => require_passthrough.hasPassThroughUsage(parser.usage)));
 	const createInitialState = () => {
 		const state = {};
 		for (const key of parserKeys) state[key] = parsers[key].initialState;
@@ -1965,6 +2066,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			success: true,
 			next: {
 				...context,
+				...require_passthrough.getPassThroughFailureHint(result.next),
 				buffer: result.next.buffer,
 				optionsTerminated: result.next.optionsTerminated,
 				state: nextState,
@@ -2001,16 +2103,19 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		let anySuccess = false;
 		const allConsumed = [];
 		const consumedFields = /* @__PURE__ */ new Set();
+		let consumingFailure;
 		let madeProgress = true;
 		while (madeProgress && currentContext.buffer.length > 0) {
 			madeProgress = false;
+			consumingFailure = void 0;
 			const getFieldState = createFieldStateGetter(currentContext.state, getObjectParseChildState);
-			for (const [field, parser] of parserPairs) {
-				const result = parser.parse(withChildContext$1(currentContext, field, getFieldState(field, parser), parser));
+			for (const [field, parser] of orderBeforePassThrough(parserPairs, currentContext, ([, parser$1]) => parser$1, ([field$1, parser$1]) => getFieldState(field$1, parser$1), passThroughParsers)) {
+				const result = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, field, getFieldState(field, parser), parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, getFieldState(field, parser), currentContext.buffer[0])));
 				if (result.success && result.consumed.length > 0) {
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
+						...require_passthrough.getPassThroughFailureHint(result.next),
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: {
@@ -2028,7 +2133,12 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					madeProgress = true;
 					consumedFields.add(field);
 					break;
-				} else if (!result.success && error.consumed < result.consumed) error = result;
+				} else if (result.success) consumingFailure = require_passthrough.retainConsumingFailureHint(consumingFailure, currentContext, result.next);
+				else {
+					const match = require_passthrough.getOptionMatch(parser, getFieldState(field, parser), currentContext.buffer[0]);
+					if (result.consumed > 0 && match != null) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, match.priority);
+					if (error.consumed < result.consumed) error = result;
+				}
 			}
 		}
 		{
@@ -2038,7 +2148,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				const typedParser = parser;
 				if (parser.leadingNames.size > 0 || typedParser.acceptingAnyToken) continue;
 				const fieldState = getFieldState(field, parser);
-				const result = typedParser.parse(withChildContext$1(currentContext, field, fieldState, parser));
+				const result = typedParser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, field, fieldState, parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, getFieldState(field, parser), currentContext.buffer[0])));
 				if (result.success && result.consumed.length === 0 && result.next.state !== fieldState) {
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
@@ -2058,7 +2168,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		}
 		if (anySuccess) return {
 			success: true,
-			next: currentContext,
+			next: require_passthrough.withPassThroughFailure(currentContext, consumingFailure),
 			consumed: allConsumed
 		};
 		if (currentContext.buffer.length === 0) {
@@ -2107,17 +2217,20 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		let anySuccess = false;
 		const allConsumed = [];
 		const consumedFields = /* @__PURE__ */ new Set();
+		let consumingFailure;
 		let madeProgress = true;
 		while (madeProgress && currentContext.buffer.length > 0) {
 			madeProgress = false;
+			consumingFailure = void 0;
 			const getFieldState = createFieldStateGetter(currentContext.state, getObjectParseChildState);
-			for (const [field, parser] of parserPairs) {
-				const resultOrPromise = parser.parse(withChildContext$1(currentContext, field, getFieldState(field, parser), parser));
+			for (const [field, parser] of orderBeforePassThrough(parserPairs, currentContext, ([, parser$1]) => parser$1, ([field$1, parser$1]) => getFieldState(field$1, parser$1), passThroughParsers)) {
+				const resultOrPromise = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, field, getFieldState(field, parser), parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, getFieldState(field, parser), currentContext.buffer[0])));
 				const result = await resultOrPromise;
 				if (result.success && result.consumed.length > 0) {
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
+						...require_passthrough.getPassThroughFailureHint(result.next),
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: {
@@ -2135,7 +2248,12 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					madeProgress = true;
 					consumedFields.add(field);
 					break;
-				} else if (!result.success && error.consumed < result.consumed) error = result;
+				} else if (result.success) consumingFailure = require_passthrough.retainConsumingFailureHint(consumingFailure, currentContext, result.next);
+				else {
+					const match = require_passthrough.getOptionMatch(parser, getFieldState(field, parser), currentContext.buffer[0]);
+					if (result.consumed > 0 && match != null) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, match.priority);
+					if (error.consumed < result.consumed) error = result;
+				}
 			}
 		}
 		{
@@ -2144,7 +2262,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				if (consumedFields.has(field)) continue;
 				if (parser.leadingNames.size > 0 || parser.acceptingAnyToken) continue;
 				const fieldState = getFieldState(field, parser);
-				const resultOrPromise = parser.parse(withChildContext$1(currentContext, field, fieldState, parser));
+				const resultOrPromise = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, field, fieldState, parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, getFieldState(field, parser), currentContext.buffer[0])));
 				const result = await resultOrPromise;
 				if (result.success && result.consumed.length === 0 && result.next.state !== fieldState) {
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
@@ -2165,7 +2283,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		}
 		if (anySuccess) return {
 			success: true,
-			next: currentContext,
+			next: require_passthrough.withPassThroughFailure(currentContext, consumingFailure),
 			consumed: allConsumed
 		};
 		if (currentContext.buffer.length === 0) {
@@ -2515,6 +2633,8 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	});
 	require_internal_parser.defineParseLanes(objectParser, objectParseLanes);
 	require_internal_parser.defineInheritedAnnotationParser(objectParser);
+	require_passthrough.defineOptionMatch(objectParser, (state, token) => require_passthrough.combineOptionMatches(parserPairs.map(([field, parser]) => require_passthrough.getOptionMatch(parser, getAnnotatedFieldState(state, typeof field === "number" ? String(field) : field, parser), token))));
+	require_passthrough.definePassThroughPriority(objectParser, parserPairs.map(([, parser]) => parser), (state, token) => require_passthrough.combinePassThroughPriorities(parserPairs.map(([field, parser]) => require_passthrough.getPassThroughPriority(parser, getAnnotatedFieldState(state, typeof field === "number" ? String(field) : field, parser), token))));
 	return require_modifiers.fluent(objectParser);
 }
 function isParserLike(value) {
@@ -2965,6 +3085,7 @@ function advanceTupleSuggestContextSync(context, parsers) {
 				const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 				currentContext = {
 					...currentContext,
+					...require_passthrough.getPassThroughFailureHint(result.next),
 					buffer: result.next.buffer,
 					optionsTerminated: result.next.optionsTerminated,
 					state: newStateArray,
@@ -3031,6 +3152,7 @@ async function advanceTupleSuggestContextAsync(context, parsers) {
 				const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 				currentContext = {
 					...currentContext,
+					...require_passthrough.getPassThroughFailureHint(result.next),
 					buffer: result.next.buffer,
 					optionsTerminated: result.next.optionsTerminated,
 					state: newStateArray,
@@ -3130,10 +3252,12 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	const combinedMode = parsers.some((p) => p.mode === "async") ? "async" : "sync";
 	const syncParsers = parsers;
 	if (!options.allowDuplicates) checkDuplicateOptionNames(parsers.map((parser, index) => [String(index), parser.usage]));
+	const passThroughParsers = new Set(parsers.filter((parser) => require_passthrough.hasPassThroughUsage(parser.usage)));
 	const parseSync = (context) => {
 		let currentContext = context;
 		const allConsumed = [];
 		const matchedParsers = /* @__PURE__ */ new Set();
+		let consumingFailure;
 		while (matchedParsers.size < syncParsers.length) {
 			let foundMatch = false;
 			let error = {
@@ -3141,14 +3265,15 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				error: require_message.message`No remaining parsers could match the input.`
 			};
 			const stateArray = currentContext.state;
-			const remainingParsers = syncParsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+			const remainingParsers = orderBeforePassThrough(syncParsers.map((parser, index) => [parser, index]).filter(([parser, index]) => !matchedParsers.has(index) || require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0])?.continuesCommand === true || passThroughParsers.size > 0 && !currentContext.optionsTerminated && require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0]) != null).sort(([parserA], [parserB]) => parserB.priority - parserA.priority), currentContext, ([parser]) => parser, ([, index]) => stateArray[index], passThroughParsers);
 			for (const [parser, index] of remainingParsers) {
-				const result = parser.parse(withChildContext$1(currentContext, index, stateArray[index], parser));
+				const result = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, index, stateArray[index], parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, stateArray[index], currentContext.buffer[0])));
 				if (result.success && result.consumed.length > 0) {
 					const newStateArray = require_internal_annotations.annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? require_annotation_state.getWrappedChildState(currentContext.state, result.next.state, parser) : s));
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
+						...require_passthrough.getPassThroughFailureHint(result.next),
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: newStateArray,
@@ -3157,14 +3282,21 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 							dependencyRegistry: mergedExec.dependencyRegistry
 						} : {}
 					};
+					consumingFailure = void 0;
 					allConsumed.push(...result.consumed);
 					matchedParsers.add(index);
 					foundMatch = true;
 					break;
-				} else if (!result.success && error.consumed < result.consumed) error = result;
+				} else if (result.success) consumingFailure = require_passthrough.retainConsumingFailureHint(consumingFailure, currentContext, result.next);
+				else {
+					const match = require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0]);
+					if (result.consumed > 0 && match != null) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, match.priority);
+					if (error.consumed < result.consumed) error = result;
+				}
 			}
 			if (!foundMatch) for (const [parser, index] of remainingParsers) {
-				const result = parser.parse(withChildContext$1(currentContext, index, stateArray[index], parser));
+				if (matchedParsers.has(index)) continue;
+				const result = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, index, stateArray[index], parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, stateArray[index], currentContext.buffer[0])));
 				if (result.success && result.consumed.length < 1) {
 					const newStateArray = require_internal_annotations.annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? require_annotation_state.getWrappedChildState(currentContext.state, result.next.state, parser) : s));
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
@@ -3192,7 +3324,7 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		}
 		return {
 			success: true,
-			next: currentContext,
+			next: require_passthrough.withPassThroughFailure(currentContext, consumingFailure),
 			consumed: allConsumed
 		};
 	};
@@ -3200,6 +3332,7 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		let currentContext = context;
 		const allConsumed = [];
 		const matchedParsers = /* @__PURE__ */ new Set();
+		let consumingFailure;
 		while (matchedParsers.size < parsers.length) {
 			let foundMatch = false;
 			let error = {
@@ -3207,15 +3340,16 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				error: require_message.message`No remaining parsers could match the input.`
 			};
 			const stateArray = currentContext.state;
-			const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+			const remainingParsers = orderBeforePassThrough(parsers.map((parser, index) => [parser, index]).filter(([parser, index]) => !matchedParsers.has(index) || require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0])?.continuesCommand === true || passThroughParsers.size > 0 && !currentContext.optionsTerminated && require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0]) != null).sort(([parserA], [parserB]) => parserB.priority - parserA.priority), currentContext, ([parser]) => parser, ([, index]) => stateArray[index], passThroughParsers);
 			for (const [parser, index] of remainingParsers) {
-				const resultOrPromise = parser.parse(withChildContext$1(currentContext, index, stateArray[index], parser));
+				const resultOrPromise = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, index, stateArray[index], parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, stateArray[index], currentContext.buffer[0])));
 				const result = await resultOrPromise;
 				if (result.success && result.consumed.length > 0) {
 					const newStateArray = require_internal_annotations.annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? require_annotation_state.getWrappedChildState(currentContext.state, result.next.state, parser) : s));
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
+						...require_passthrough.getPassThroughFailureHint(result.next),
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: newStateArray,
@@ -3224,14 +3358,21 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 							dependencyRegistry: mergedExec.dependencyRegistry
 						} : {}
 					};
+					consumingFailure = void 0;
 					allConsumed.push(...result.consumed);
 					matchedParsers.add(index);
 					foundMatch = true;
 					break;
-				} else if (!result.success && error.consumed < result.consumed) error = result;
+				} else if (result.success) consumingFailure = require_passthrough.retainConsumingFailureHint(consumingFailure, currentContext, result.next);
+				else {
+					const match = require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0]);
+					if (result.consumed > 0 && match != null) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, match.priority);
+					if (error.consumed < result.consumed) error = result;
+				}
 			}
 			if (!foundMatch) for (const [parser, index] of remainingParsers) {
-				const resultOrPromise = parser.parse(withChildContext$1(currentContext, index, stateArray[index], parser));
+				if (matchedParsers.has(index)) continue;
+				const resultOrPromise = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, index, stateArray[index], parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, stateArray[index], currentContext.buffer[0])));
 				const result = await resultOrPromise;
 				if (result.success && result.consumed.length < 1) {
 					const newStateArray = require_internal_annotations.annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? require_annotation_state.getWrappedChildState(currentContext.state, result.next.state, parser) : s));
@@ -3260,7 +3401,7 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		}
 		return {
 			success: true,
-			next: currentContext,
+			next: require_passthrough.withPassThroughFailure(currentContext, consumingFailure),
 			consumed: allConsumed
 		};
 	};
@@ -3513,6 +3654,8 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		enumerable: false
 	});
 	require_internal_parser.defineInheritedAnnotationParser(tupleParser);
+	require_passthrough.defineOptionMatch(tupleParser, (state, token) => require_passthrough.combineOptionMatches(parsers.map((parser, index) => require_passthrough.getOptionMatch(parser, require_annotation_state.getWrappedChildState(state, state[index], parser), token))));
+	require_passthrough.definePassThroughPriority(tupleParser, parsers, (state, token) => require_passthrough.combinePassThroughPriorities(parsers.map((parser, index) => require_passthrough.getPassThroughPriority(parser, require_annotation_state.getWrappedChildState(state, state[index], parser), token))));
 	return require_modifiers.fluent(tupleParser);
 }
 function seq(...rawArgs) {
@@ -3926,6 +4069,7 @@ function merge(...args) {
 			success: true,
 			next: {
 				...context,
+				...require_passthrough.getPassThroughFailureHint(result.next),
 				buffer: result.next.buffer,
 				optionsTerminated: result.next.optionsTerminated,
 				state: newState,
@@ -4031,6 +4175,7 @@ function merge(...args) {
 			const mergedExec = require_execution_context.mergeChildExec(settledContext.exec, result.next.exec);
 			settledContext = {
 				...settledContext,
+				...require_passthrough.getPassThroughFailureHint(result.next),
 				buffer: result.next.buffer,
 				optionsTerminated: result.next.optionsTerminated,
 				state: nextState,
@@ -4063,6 +4208,7 @@ function merge(...args) {
 				const newState = mergeResultState(parser, currentContext, parserState, result, i);
 				const newContext = {
 					...currentContext,
+					...require_passthrough.getPassThroughFailureHint(result.next),
 					buffer: result.next.buffer,
 					optionsTerminated: result.next.optionsTerminated,
 					state: newState,
@@ -4108,6 +4254,7 @@ function merge(...args) {
 				const newState = mergeResultState(parser, currentContext, parserState, result, i);
 				const newContext = {
 					...currentContext,
+					...require_passthrough.getPassThroughFailureHint(result.next),
 					buffer: result.next.buffer,
 					optionsTerminated: result.next.optionsTerminated,
 					state: newState,
@@ -4147,10 +4294,12 @@ function merge(...args) {
 		const consumedLanes = /* @__PURE__ */ new Set();
 		const consumedGroups = /* @__PURE__ */ new Set();
 		const laneResults = /* @__PURE__ */ new Map();
+		let consumingFailure;
 		let attemptedLane = false;
 		let madeProgress = true;
 		while (madeProgress && currentContext.buffer.length > 0) {
 			madeProgress = false;
+			consumingFailure = void 0;
 			let consumingError = null;
 			for (const lane of mergeParseLanes) {
 				if (consumingError != null && lane.priority < consumingError.priority) {
@@ -4168,6 +4317,10 @@ function merge(...args) {
 					break;
 				}
 				if (!result.success) {
+					if (result.consumed > 0 && require_passthrough.matchesOptionToken({
+						leadingNames: lane.leadingNames,
+						usage: parsers.flatMap((parser) => parser.usage)
+					}, currentContext.buffer[0])) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, lane.priority);
 					if (result.consumed > 0 && consumingError == null) consumingError = {
 						priority: lane.priority,
 						result
@@ -4199,7 +4352,7 @@ function merge(...args) {
 		}
 		return {
 			success: true,
-			next: currentContext,
+			next: require_passthrough.withPassThroughFailure(currentContext, consumingFailure),
 			consumed: allConsumed
 		};
 	};
@@ -4210,10 +4363,12 @@ function merge(...args) {
 		const consumedLanes = /* @__PURE__ */ new Set();
 		const consumedGroups = /* @__PURE__ */ new Set();
 		const laneResults = /* @__PURE__ */ new Map();
+		let consumingFailure;
 		let attemptedLane = false;
 		let madeProgress = true;
 		while (madeProgress && currentContext.buffer.length > 0) {
 			madeProgress = false;
+			consumingFailure = void 0;
 			let consumingError = null;
 			for (const lane of mergeParseLanes) {
 				if (consumingError != null && lane.priority < consumingError.priority) {
@@ -4231,6 +4386,10 @@ function merge(...args) {
 					break;
 				}
 				if (!result.success) {
+					if (result.consumed > 0 && require_passthrough.matchesOptionToken({
+						leadingNames: lane.leadingNames,
+						usage: parsers.flatMap((parser) => parser.usage)
+					}, currentContext.buffer[0])) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, lane.priority);
 					if (result.consumed > 0 && consumingError == null) consumingError = {
 						priority: lane.priority,
 						result
@@ -4262,7 +4421,7 @@ function merge(...args) {
 		}
 		return {
 			success: true,
-			next: currentContext,
+			next: require_passthrough.withPassThroughFailure(currentContext, consumingFailure),
 			consumed: allConsumed
 		};
 	};
@@ -4751,6 +4910,8 @@ function merge(...args) {
 	};
 	require_internal_parser.defineParseLanes(mergeParser, mergeParseLanes);
 	require_internal_parser.defineInheritedAnnotationParser(mergeParser);
+	require_passthrough.defineOptionMatch(mergeParser, (state, token) => require_passthrough.combineOptionMatches(sorted.map(([parser], index) => require_passthrough.getOptionMatch(parser, extractParserStateFromState(parser, state, index), token))));
+	require_passthrough.definePassThroughPriority(mergeParser, parsers, (state, token) => require_passthrough.combinePassThroughPriorities(sorted.map(([parser], index) => require_passthrough.getPassThroughPriority(parser, extractParserStateFromState(parser, state, index), token))));
 	return require_modifiers.fluent(mergeParser);
 }
 /**
@@ -4941,6 +5102,7 @@ function tryParseSuggestList(context, stateArray, parsers, matchedParsers, remai
 					const mergedExec = require_execution_context.mergeChildExec(context.exec, result$1.next.exec);
 					return preParseSuggestLoop({
 						...context,
+						...require_passthrough.getPassThroughFailureHint(result$1.next),
 						buffer: result$1.next.buffer,
 						optionsTerminated: result$1.next.optionsTerminated,
 						state: stateArray,
@@ -4968,6 +5130,7 @@ function tryParseSuggestList(context, stateArray, parsers, matchedParsers, remai
 			const mergedExec = require_execution_context.mergeChildExec(context.exec, result.next.exec);
 			return {
 				...context,
+				...require_passthrough.getPassThroughFailureHint(result.next),
 				buffer: result.next.buffer,
 				optionsTerminated: result.next.optionsTerminated,
 				state: stateArray,
@@ -4987,10 +5150,12 @@ function concat(...parsers) {
 	const isAsync = combinedMode === "async";
 	const syncParsers = parsers;
 	const initialState = parsers.map((parser) => parser.initialState);
+	const passThroughParsers = new Set(parsers.filter((parser) => require_passthrough.hasPassThroughUsage(parser.usage)));
 	const parseSync = (context) => {
 		let currentContext = context;
 		const allConsumed = [];
 		const matchedParsers = /* @__PURE__ */ new Set();
+		let consumingFailure;
 		while (matchedParsers.size < syncParsers.length) {
 			let foundMatch = false;
 			let error = {
@@ -4998,14 +5163,15 @@ function concat(...parsers) {
 				error: require_message.message`No remaining parsers could match the input.`
 			};
 			const stateArray = currentContext.state;
-			const remainingParsers = syncParsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+			const remainingParsers = orderBeforePassThrough(syncParsers.map((parser, index) => [parser, index]).filter(([parser, index]) => !matchedParsers.has(index) || require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0])?.continuesCommand === true || passThroughParsers.size > 0 && !currentContext.optionsTerminated && require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0]) != null).sort(([parserA], [parserB]) => parserB.priority - parserA.priority), currentContext, ([parser]) => parser, ([, index]) => stateArray[index], passThroughParsers);
 			for (const [parser, index] of remainingParsers) {
-				const result = parser.parse(withChildContext$1(currentContext, index, stateArray[index], parser));
+				const result = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, index, stateArray[index], parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, stateArray[index], currentContext.buffer[0])));
 				if (result.success && result.consumed.length > 0) {
 					const newStateArray = require_internal_annotations.annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? require_annotation_state.getWrappedChildState(currentContext.state, result.next.state, parser) : s));
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
+						...require_passthrough.getPassThroughFailureHint(result.next),
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: newStateArray,
@@ -5014,14 +5180,21 @@ function concat(...parsers) {
 							dependencyRegistry: mergedExec.dependencyRegistry
 						} : {}
 					};
+					consumingFailure = void 0;
 					allConsumed.push(...result.consumed);
 					matchedParsers.add(index);
 					foundMatch = true;
 					break;
-				} else if (!result.success && error.consumed < result.consumed) error = result;
+				} else if (result.success) consumingFailure = require_passthrough.retainConsumingFailureHint(consumingFailure, currentContext, result.next);
+				else {
+					const match = require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0]);
+					if (result.consumed > 0 && match != null) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, match.priority);
+					if (error.consumed < result.consumed) error = result;
+				}
 			}
 			if (!foundMatch) for (const [parser, index] of remainingParsers) {
-				const result = parser.parse(withChildContext$1(currentContext, index, stateArray[index], parser));
+				if (matchedParsers.has(index)) continue;
+				const result = parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, index, stateArray[index], parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, stateArray[index], currentContext.buffer[0])));
 				if (result.success && result.consumed.length < 1) {
 					const newStateArray = require_internal_annotations.annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? require_annotation_state.getWrappedChildState(currentContext.state, result.next.state, parser) : s));
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
@@ -5049,7 +5222,7 @@ function concat(...parsers) {
 		}
 		return {
 			success: true,
-			next: currentContext,
+			next: require_passthrough.withPassThroughFailure(currentContext, consumingFailure),
 			consumed: allConsumed
 		};
 	};
@@ -5057,6 +5230,7 @@ function concat(...parsers) {
 		let currentContext = context;
 		const allConsumed = [];
 		const matchedParsers = /* @__PURE__ */ new Set();
+		let consumingFailure;
 		while (matchedParsers.size < parsers.length) {
 			let foundMatch = false;
 			let error = {
@@ -5064,14 +5238,15 @@ function concat(...parsers) {
 				error: require_message.message`No remaining parsers could match the input.`
 			};
 			const stateArray = currentContext.state;
-			const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+			const remainingParsers = orderBeforePassThrough(parsers.map((parser, index) => [parser, index]).filter(([parser, index]) => !matchedParsers.has(index) || require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0])?.continuesCommand === true || passThroughParsers.size > 0 && !currentContext.optionsTerminated && require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0]) != null).sort(([parserA], [parserB]) => parserB.priority - parserA.priority), currentContext, ([parser]) => parser, ([, index]) => stateArray[index], passThroughParsers);
 			for (const [parser, index] of remainingParsers) {
-				const result = await parser.parse(withChildContext$1(currentContext, index, stateArray[index], parser));
+				const result = await parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, index, stateArray[index], parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, stateArray[index], currentContext.buffer[0])));
 				if (result.success && result.consumed.length > 0) {
 					const newStateArray = require_internal_annotations.annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? require_annotation_state.getWrappedChildState(currentContext.state, result.next.state, parser) : s));
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
+						...require_passthrough.getPassThroughFailureHint(result.next),
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: newStateArray,
@@ -5080,14 +5255,21 @@ function concat(...parsers) {
 							dependencyRegistry: mergedExec.dependencyRegistry
 						} : {}
 					};
+					consumingFailure = void 0;
 					allConsumed.push(...result.consumed);
 					matchedParsers.add(index);
 					foundMatch = true;
 					break;
-				} else if (!result.success && error.consumed < result.consumed) error = result;
+				} else if (result.success) consumingFailure = require_passthrough.retainConsumingFailureHint(consumingFailure, currentContext, result.next);
+				else {
+					const match = require_passthrough.getOptionMatch(parser, stateArray[index], currentContext.buffer[0]);
+					if (result.consumed > 0 && match != null) consumingFailure = require_passthrough.retainConsumingFailure(consumingFailure, result, match.priority);
+					if (error.consumed < result.consumed) error = result;
+				}
 			}
 			if (!foundMatch) for (const [parser, index] of remainingParsers) {
-				const result = await parser.parse(withChildContext$1(currentContext, index, stateArray[index], parser));
+				if (matchedParsers.has(index)) continue;
+				const result = await parser.parse(require_passthrough.withPassThroughFailure(withChildContext$1(currentContext, index, stateArray[index], parser), consumingFailure, require_passthrough.getPassThroughPriority(parser, stateArray[index], currentContext.buffer[0])));
 				if (result.success && result.consumed.length < 1) {
 					const newStateArray = require_internal_annotations.annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? require_annotation_state.getWrappedChildState(currentContext.state, result.next.state, parser) : s));
 					const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
@@ -5115,7 +5297,7 @@ function concat(...parsers) {
 		}
 		return {
 			success: true,
-			next: currentContext,
+			next: require_passthrough.withPassThroughFailure(currentContext, consumingFailure),
 			consumed: allConsumed
 		};
 	};
@@ -5365,6 +5547,8 @@ function concat(...parsers) {
 		}
 	};
 	require_internal_parser.defineInheritedAnnotationParser(concatParser);
+	require_passthrough.defineOptionMatch(concatParser, (state, token) => require_passthrough.combineOptionMatches(parsers.map((parser, index) => require_passthrough.getOptionMatch(parser, require_annotation_state.getWrappedChildState(state, state[index], parser), token))));
+	require_passthrough.definePassThroughPriority(concatParser, parsers, (state, token) => require_passthrough.combinePassThroughPriorities(parsers.map((parser, index) => require_passthrough.getPassThroughPriority(parser, require_annotation_state.getWrappedChildState(state, state[index], parser), token))));
 	return require_modifiers.fluent(concatParser);
 }
 function group(label, parser, options = {}) {
@@ -5457,6 +5641,9 @@ function group(label, parser, options = {}) {
 		configurable: true,
 		enumerable: false
 	});
+	require_passthrough.delegateKnownCompletion(groupParser, parser);
+	require_passthrough.defineOptionMatch(groupParser, (state, token) => require_passthrough.getOptionMatch(parser, state, token));
+	require_passthrough.definePassThroughPriority(groupParser, [parser], (state, token) => require_passthrough.getPassThroughPriority(parser, state, token));
 	return require_modifiers.fluent(groupParser);
 }
 /**
@@ -5611,6 +5798,7 @@ function conditional(discriminator, branches, defaultBranch, options) {
 								dependencyRegistry: discriminatorExec.dependencyRegistry
 							} : {}
 						}, "_branch", branchParser.initialState, branchParser, branchParser.usage),
+						...require_passthrough.getPassThroughFailureHint(discriminatorResult.next),
 						buffer: discriminatorResult.next.buffer,
 						optionsTerminated: discriminatorResult.next.optionsTerminated
 					});
@@ -5732,6 +5920,7 @@ function conditional(discriminator, branches, defaultBranch, options) {
 				const discriminatorExec = require_execution_context.mergeChildExec(context.exec, discriminatorResult.next.exec);
 				const speculationContext = {
 					...context,
+					...require_passthrough.getPassThroughFailureHint(discriminatorResult.next),
 					buffer: discriminatorResult.next.buffer,
 					optionsTerminated: discriminatorResult.next.optionsTerminated,
 					...discriminatorExec != null ? {
@@ -5859,6 +6048,7 @@ function conditional(discriminator, branches, defaultBranch, options) {
 								dependencyRegistry: discriminatorExec.dependencyRegistry
 							} : {}
 						}, "_branch", branchParser.initialState, branchParser, branchParser.usage),
+						...require_passthrough.getPassThroughFailureHint(discriminatorResult.next),
 						buffer: discriminatorResult.next.buffer,
 						optionsTerminated: discriminatorResult.next.optionsTerminated
 					});
@@ -6426,6 +6616,36 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		}
 	};
 	require_internal_parser.defineInheritedAnnotationParser(conditionalParser);
+	const reachableBranches = (state) => {
+		if (state.selectedBranch != null) {
+			const branch = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
+			return branch == null ? [] : [{
+				branch,
+				state: state.branchState
+			}];
+		}
+		const known = require_passthrough.getKnownCompletion(discriminator, state.discriminatorState);
+		if (known != null) {
+			const branch = typeof known.value === "string" ? branches[known.value] : void 0;
+			const reachable = branch ?? defaultBranch;
+			return reachable == null ? [] : [{
+				branch: reachable,
+				state: reachable.initialState
+			}];
+		}
+		return allBranchParsers.map((branch) => ({
+			branch,
+			state: branch.initialState
+		}));
+	};
+	require_passthrough.definePassThroughPriority(conditionalParser, [discriminator, ...allBranchParsers], (state, token) => require_passthrough.combinePassThroughPriorities([...state.selectedBranch == null ? [require_passthrough.getPassThroughPriority(discriminator, state.discriminatorState, token)] : [], ...reachableBranches(state).map(({ branch, state: state$1 }) => require_passthrough.getPassThroughPriority(branch, state$1, token))]));
+	require_passthrough.defineOptionMatch(conditionalParser, (state, token) => {
+		if (state.selectedBranch != null) {
+			const branch = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
+			return branch == null ? void 0 : require_passthrough.getOptionMatch(branch, state.branchState, token);
+		}
+		return require_passthrough.combineOptionMatches([require_passthrough.getOptionMatch(discriminator, state.discriminatorState, token), ...reachableBranches(state).map(({ branch, state: state$1 }) => require_passthrough.getOptionMatch(branch, state$1, token))]);
+	});
 	return require_modifiers.fluent(conditionalParser);
 }