@optique/core 1.1.0-dev.2087 → 1.1.0-dev.2146

package/dist/constructs.js

@@ -8,9 +8,10 @@ import { createDependencySourceState, dependencyId, isDependencySourceState, isP
 import { buildRuntimeNodesFromArray, buildRuntimeNodesFromPairs, collectExplicitSourceValues, collectExplicitSourceValuesAsync, collectSourcesFromState, createDependencyRuntimeContext, fillMissingSourceDefaults, fillMissingSourceDefaultsAsync, resolveStateWithRuntime, resolveStateWithRuntimeAsync } from "./dependency-runtime.js";
 import { defineInheritedAnnotationParser, getParserSuggestRuntimeNodes, unmatchedNonCliDependencySourceStateMarker } from "./internal/parser.js";
 import { annotationViewTargets, getWrappedChildParseState, getWrappedChildState, reconcileObjectChildState, unwrapAnnotationView } from "./annotation-state.js";
+import { allowDuplicateLeadingCommandNamesKey } from "./internal/command-alias.js";
 import { mergeChildExec, withChildContext, withChildExecPath } from "./execution-context.js";
 import { completeOrExtractPhase2Seed, extractPhase2Seed, extractPhase2SeedKey, phase2SeedFromValueResult } from "./phase2-seed.js";
-import { DEFAULT_FIND_SIMILAR_OPTIONS, createErrorWithSuggestions, createSuggestionMessage, deduplicateSuggestions, findSimilar } from "./suggestion.js";
+import { DEFAULT_FIND_SIMILAR_OPTIONS, createErrorWithSuggestions, createSuggestionMessage, deduplicateSuggestions, expandCommandAliasSuggestions, findSimilar } from "./suggestion.js";
 import { collectLeadingCandidates } from "./usage-internals.js";
 
 //#region src/constructs.ts
@@ -301,7 +302,12 @@ function createUnexpectedInputErrorWithScopedSuggestions(baseError, invalidInput
 	for (const parser of parsers) collectLeadingCandidates(parser.usage, options, commands);
 	const candidates = new Set([...options, ...commands]);
 	const suggestions = findSimilar(invalidInput, candidates, DEFAULT_FIND_SIMILAR_OPTIONS);
-	const suggestionMsg = customFormatter ? customFormatter(suggestions) : createSuggestionMessage(suggestions);
+	const aliasUsage = [{
+		type: "exclusive",
+		terms: parsers.map((parser) => parser.usage)
+	}];
+	const displaySuggestions = expandCommandAliasSuggestions(aliasUsage, suggestions);
+	const suggestionMsg = customFormatter ? customFormatter(displaySuggestions) : createSuggestionMessage(displaySuggestions);
 	return suggestionMsg.length > 0 ? [
 		...baseError,
 		text("\n\n"),
@@ -319,6 +325,10 @@ function applyHiddenToUsageTerm(term, hidden) {
 		terms: applyHiddenToUsage(term.terms, hidden),
 		min: term.min
 	};
+	if (term.type === "sequence") return {
+		type: "sequence",
+		terms: applyHiddenToUsage(term.terms, hidden)
+	};
 	if (term.type === "exclusive") return {
 		type: "exclusive",
 		terms: term.terms.map((u) => applyHiddenToUsage(u, hidden))
@@ -374,7 +384,7 @@ function isOptionRequiringValue(usage, token) {
 		if (!terms || !Array.isArray(terms)) return false;
 		for (const term of terms) if (term.type === "option") {
 			if (term.metavar && term.names.includes(token)) return true;
-		} else if (term.type === "optional" || term.type === "multiple") {
+		} else if (term.type === "optional" || term.type === "multiple" || term.type === "sequence") {
 			if (traverse(term.terms)) return true;
 		} else if (term.type === "exclusive") {
 			for (const exclusiveUsage of term.terms) if (traverse(exclusiveUsage)) return true;
@@ -453,6 +463,18 @@ var DuplicateOptionError = class extends Error {
 	}
 };
 /**
+* Error class thrown when duplicate command names or aliases are detected
+* during parser construction. This is a programmer error, not a user error.
+*/
+var DuplicateCommandNameError = class extends TypeError {
+	constructor(commandName, sources) {
+		const sourceNames = sources.map((s) => typeof s === "symbol" ? s.description ?? s.toString() : s);
+		super(`Duplicate command name "${commandName}" found in parsers: ${sourceNames.join(", ")}. Each command name or alias must be unique within active parser alternatives.`);
+		this.commandName = commandName;
+		this.sources = sources;
+	}
+};
+/**
 * Checks for duplicate option names across parser sources and throws an error
 * if duplicates are found. This should be called at construction time.
 * @param parserSources Array of [source, usage] tuples
@@ -469,6 +491,48 @@ function checkDuplicateOptionNames(parserSources) {
 	}
 	for (const [name, sources] of optionNameSources) if (sources.length > 1) throw new DuplicateOptionError(name, sources);
 }
+function checkDuplicateLeadingCommandNames(parserSources) {
+	const commandNameSources = /* @__PURE__ */ new Map();
+	for (const [source, parser] of parserSources) {
+		const commandNames = extractCommandNames(parser.usage, true);
+		for (const name of parser.leadingNames) {
+			if (!commandNames.has(name)) continue;
+			const sources = commandNameSources.get(name);
+			commandNameSources.set(name, sources == null ? [source] : [...sources, source]);
+		}
+	}
+	for (const [name, sources] of commandNameSources) if (sources.length > 1) throw new DuplicateCommandNameError(name, sources);
+}
+function checkDuplicateReachableLeadingCommandNames(parserSources) {
+	const commandNameSources = /* @__PURE__ */ new Map();
+	const sortedSources = [...parserSources].sort(([, parserA], [, parserB]) => parserB.priority - parserA.priority);
+	const blockedNames = /* @__PURE__ */ new Set();
+	let positionalBlocked = false;
+	for (let i = 0; i < sortedSources.length;) {
+		const priority = sortedSources[i][1].priority;
+		const priorityGroup = [];
+		while (i < sortedSources.length && sortedSources[i][1].priority === priority) {
+			priorityGroup.push(sortedSources[i]);
+			i++;
+		}
+		const groupNames = /* @__PURE__ */ new Set();
+		let groupAcceptsAnyToken = false;
+		for (const [source, parser] of priorityGroup) {
+			if (parser.acceptingAnyToken) groupAcceptsAnyToken = true;
+			const commandNames = extractCommandNames(parser.usage, true);
+			for (const name of parser.leadingNames) {
+				if (!commandNames.has(name)) continue;
+				if (positionalBlocked || blockedNames.has(name)) continue;
+				groupNames.add(name);
+				const sources = commandNameSources.get(name);
+				commandNameSources.set(name, sources == null ? [source] : [...sources, source]);
+			}
+		}
+		for (const name of groupNames) blockedNames.add(name);
+		if (groupAcceptsAnyToken) positionalBlocked = true;
+	}
+	for (const [name, sources] of commandNameSources) if (sources.length > 1) throw new DuplicateCommandNameError(name, sources);
+}
 /**
 * Extracts option names that participate in CLI syntax.
 *
@@ -733,6 +797,7 @@ function or(...args) {
 	}
 	if (parsers.length < 1) throw new TypeError("or() requires at least one parser argument.");
 	assertParsers(parsers, "or()");
+	checkDuplicateLeadingCommandNames(parsers.map((parser, index) => [String(index), parser]));
 	const noMatchContext = analyzeNoMatchContext(parsers);
 	const combinedMode = parsers.some((p) => p.mode === "async") ? "async" : "sync";
 	const syncParsers = parsers;
@@ -1152,6 +1217,15 @@ function or(...args) {
 		leadingNames: unionLeadingNames(parsers),
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState: void 0,
+		canSkip(state, exec) {
+			const activeState = normalizeExclusiveState(state);
+			if (activeState != null) {
+				const [index, result] = activeState;
+				const parser = parsers[index];
+				return result.success && parser?.canSkip?.(result.next.state, exec) === true;
+			}
+			return parsers.some((parser) => parser.canSkip?.(parser.initialState, exec) === true);
+		},
 		complete: createExclusiveComplete(parsers, options, noMatchContext, combinedMode),
 		[extractPhase2SeedKey](state, exec) {
 			return extractExclusivePhase2Seed(parsers, state, exec, combinedMode);
@@ -1199,6 +1273,9 @@ function or(...args) {
 * @since 0.5.0
 */
 function longestMatch(...args) {
+	return createLongestMatch(...args);
+}
+function createLongestMatch(...args) {
 	let parsers;
 	let options;
 	if (args.length > 0 && args[args.length - 1] && typeof args[args.length - 1] === "object" && !("$valueType" in args[args.length - 1])) {
@@ -1210,6 +1287,8 @@ function longestMatch(...args) {
 	}
 	if (parsers.length < 1) throw new TypeError("longestMatch() requires at least one parser argument.");
 	assertParsers(parsers, "longestMatch()");
+	const allowDuplicateLeadingCommandNames = options?.[allowDuplicateLeadingCommandNamesKey] === true;
+	if (!allowDuplicateLeadingCommandNames) checkDuplicateLeadingCommandNames(parsers.map((parser, index) => [String(index), parser]));
 	const noMatchContext = analyzeNoMatchContext(parsers);
 	const combinedMode = parsers.some((p) => p.mode === "async") ? "async" : "sync";
 	const syncParsers = parsers;
@@ -1755,6 +1834,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		};
 	};
 	if (!options.allowDuplicates) checkDuplicateOptionNames(parserPairs.map(([field, parser]) => [field, parser.usage]));
+	checkDuplicateReachableLeadingCommandNames(parserPairs.map(([field, parser]) => [field, parser]));
 	const noMatchContext = analyzeNoMatchContext(parserKeys.map((k) => parsers[k]));
 	const combinedMode = parserKeys.some((k) => parsers[k].mode === "async") ? "async" : "sync";
 	const getInitialError = (context) => ({
@@ -1992,6 +2072,13 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		usage: applyHiddenToUsage(parserPairs.flatMap(([_, p]) => p.usage), options.hidden),
 		leadingNames: sharedBufferLeadingNames(parserPairs.map(([_, p]) => p)),
 		acceptingAnyToken: parserPairs.some(([_, p]) => p.acceptingAnyToken),
+		canSkip(state, exec) {
+			const getFieldState = createFieldStateGetter(state);
+			return parserKeys.every((field) => {
+				const parser = parsers[field];
+				return parser.canSkip?.(getFieldState(field, parser), withChildExecPath(exec, field)) === true;
+			});
+		},
 		get initialState() {
 			return createInitialState();
 		},
@@ -2284,6 +2371,369 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	defineInheritedAnnotationParser(objectParser);
 	return objectParser;
 }
+function isParserLike(value) {
+	return value != null && (typeof value === "object" || typeof value === "function") && "parse" in value && "$valueType" in value && "$stateType" in value;
+}
+function tokenMatchesLeadingName(token, candidates) {
+	if (token == null) return false;
+	for (const name of candidates.optionNames) if (token === name) return true;
+	for (const name of candidates.joinedOptionNames) if (name.startsWith("/") && token.startsWith(`${name}:`) || (name.startsWith("--") || name.startsWith("-") && name.length > 2) && token.startsWith(`${name}=`)) return true;
+	for (const name of candidates.commandNames) if (token === name) return true;
+	return false;
+}
+function parserCanSkipAt(parser, state, exec, index) {
+	return parser.canSkip?.(getWrappedChildState(void 0, state, parser), withChildExecPath(exec, index)) === true;
+}
+function collectLeadingJoinedOptionNames(terms, optionNames) {
+	for (const term of terms) {
+		if (term.type === "option") {
+			if (term.metavar != null) for (const name of term.names) optionNames.add(name);
+			return false;
+		}
+		if (term.type === "command" || term.type === "argument") return false;
+		if (term.type === "optional") {
+			collectLeadingJoinedOptionNames(term.terms, optionNames);
+			continue;
+		}
+		if (term.type === "multiple") {
+			collectLeadingJoinedOptionNames(term.terms, optionNames);
+			if (term.min === 0) continue;
+			return false;
+		}
+		if (term.type === "sequence") {
+			if (collectLeadingJoinedOptionNames(term.terms, optionNames)) continue;
+			return false;
+		}
+		if (term.type === "exclusive") {
+			let allSkippable = true;
+			for (const branch of term.terms) {
+				const branchSkippable = collectLeadingJoinedOptionNames(branch, optionNames);
+				allSkippable = allSkippable && branchSkippable;
+			}
+			if (allSkippable) continue;
+			return false;
+		}
+	}
+	return true;
+}
+function sequenceLeadingCandidates(parsers) {
+	const optionNames = /* @__PURE__ */ new Set();
+	const joinedOptionNames = /* @__PURE__ */ new Set();
+	const commandNames = /* @__PURE__ */ new Set();
+	let positionalBlocked = false;
+	for (let i = 0; i < parsers.length; i++) {
+		const parser = parsers[i];
+		const parserOptions = /* @__PURE__ */ new Set();
+		const parserJoinedOptions = /* @__PURE__ */ new Set();
+		const parserCommands = /* @__PURE__ */ new Set();
+		collectLeadingCandidates(parser.usage, parserOptions, parserCommands);
+		collectLeadingJoinedOptionNames(parser.usage, parserJoinedOptions);
+		for (const name of parserOptions) optionNames.add(name);
+		for (const name of parserJoinedOptions) joinedOptionNames.add(name);
+		if (!positionalBlocked) {
+			for (const name of parserCommands) commandNames.add(name);
+			for (const name of parser.leadingNames) if (!parserOptions.has(name)) commandNames.add(name);
+		} else for (const name of parser.leadingNames) if (!parserOptions.has(name) && name.startsWith("-")) commandNames.add(name);
+		if (parser.acceptingAnyToken) positionalBlocked = true;
+		if (!parserCanSkipAt(parser, parser.initialState, void 0, i)) break;
+	}
+	return {
+		optionNames: optionNames.size === 0 ? EMPTY_LEADING_NAMES : optionNames,
+		joinedOptionNames: joinedOptionNames.size === 0 ? EMPTY_LEADING_NAMES : joinedOptionNames,
+		commandNames: commandNames.size === 0 ? EMPTY_LEADING_NAMES : commandNames
+	};
+}
+function sequenceLeadingNames(parsers) {
+	const candidates = sequenceLeadingCandidates(parsers);
+	const names = new Set([
+		...candidates.optionNames,
+		...candidates.joinedOptionNames,
+		...candidates.commandNames
+	]);
+	return names.size === 0 ? EMPTY_LEADING_NAMES : names;
+}
+function sequenceAcceptingAnyToken(parsers) {
+	for (let i = 0; i < parsers.length; i++) {
+		const parser = parsers[i];
+		if (parser.acceptingAnyToken) return true;
+		if (!parserCanSkipAt(parser, parser.initialState, void 0, i)) break;
+	}
+	return false;
+}
+function sequencePriority(parsers) {
+	let priority = 0;
+	for (let i = 0; i < parsers.length; i++) {
+		const parser = parsers[i];
+		priority = Math.max(priority, parser.priority);
+		if (!parserCanSkipAt(parser, parser.initialState, void 0, i)) break;
+	}
+	return priority;
+}
+function leadingCandidatesAfter(parsers, startIndex) {
+	return sequenceLeadingCandidates(parsers.slice(startIndex));
+}
+function checkSequentialDuplicateOptionNames(parsers) {
+	const active = /* @__PURE__ */ new Map();
+	for (let i = 0; i < parsers.length; i++) {
+		const parser = parsers[i];
+		const optionNames = /* @__PURE__ */ new Set();
+		collectLeadingCandidates(parser.usage, optionNames, /* @__PURE__ */ new Set(), true);
+		const retainedOptionNames = collectRetainedLeadingCandidates(parser.usage).optionNames;
+		for (const name of optionNames) {
+			const sources = active.get(name);
+			if (sources != null) throw new DuplicateOptionError(name, [...sources, String(i)]);
+		}
+		for (const name of optionNames) {
+			const sources = active.get(name);
+			active.set(name, sources == null ? [String(i)] : [...sources, String(i)]);
+		}
+		if (!parserCanSkipAt(parser, parser.initialState, void 0, i)) active.clear();
+		for (const name of retainedOptionNames) {
+			const sources = active.get(name);
+			active.set(name, sources == null ? [String(i)] : [...sources, String(i)]);
+		}
+	}
+}
+function collectRetainedLeadingCandidates(terms) {
+	const optionNames = /* @__PURE__ */ new Set();
+	const joinedOptionNames = /* @__PURE__ */ new Set();
+	collectRetainedLeadingCandidatesInto(terms, optionNames, joinedOptionNames);
+	return {
+		optionNames,
+		joinedOptionNames,
+		commandNames: EMPTY_LEADING_NAMES
+	};
+}
+function collectRetainedLeadingCandidatesInto(terms, optionNames, joinedOptionNames) {
+	for (const term of terms) {
+		if (term.type === "optional") {
+			collectLeadingOptionCandidates(term.terms, optionNames, joinedOptionNames);
+			collectRetainedLeadingCandidatesInto(term.terms, optionNames, joinedOptionNames);
+			continue;
+		}
+		if (term.type === "multiple") {
+			collectLeadingOptionCandidates(term.terms, optionNames, joinedOptionNames);
+			collectRetainedLeadingCandidatesInto(term.terms, optionNames, joinedOptionNames);
+			continue;
+		}
+		if (term.type === "sequence") {
+			collectRetainedLeadingCandidatesInto(term.terms, optionNames, joinedOptionNames);
+			continue;
+		}
+		if (term.type === "exclusive") {
+			let canSkipBranch = false;
+			const branchOptionNames = [];
+			const branchJoinedOptionNames = [];
+			for (const branch of term.terms) {
+				const branchOptions = /* @__PURE__ */ new Set();
+				const branchJoinedOptions = /* @__PURE__ */ new Set();
+				const branchCanSkip = collectLeadingCandidates(branch, branchOptions, /* @__PURE__ */ new Set(), true);
+				collectLeadingJoinedOptionNames(branch, branchJoinedOptions);
+				canSkipBranch = canSkipBranch || branchCanSkip;
+				branchOptionNames.push(branchOptions);
+				branchJoinedOptionNames.push(branchJoinedOptions);
+				collectRetainedLeadingCandidatesInto(branch, optionNames, joinedOptionNames);
+			}
+			if (canSkipBranch) {
+				for (const branchOptions of branchOptionNames) for (const name of branchOptions) optionNames.add(name);
+				for (const branchJoinedOptions of branchJoinedOptionNames) for (const name of branchJoinedOptions) joinedOptionNames.add(name);
+			}
+		}
+	}
+}
+function collectLeadingOptionCandidates(terms, optionNames, joinedOptionNames) {
+	collectLeadingCandidates(terms, optionNames, /* @__PURE__ */ new Set(), true);
+	collectLeadingJoinedOptionNames(terms, joinedOptionNames);
+}
+function collectRetainedLeadingCandidatesAtState(terms, state) {
+	if (terms.length === 1 && terms[0].type === "optional" && Array.isArray(state)) return collectRetainedLeadingCandidates(terms[0].terms);
+	return collectRetainedLeadingCandidates(terms);
+}
+function createSeqState(sourceState, index, states) {
+	const seqState = {
+		index,
+		states: annotateFreshArray(sourceState, states)
+	};
+	return inheritAnnotations(sourceState, seqState);
+}
+function getSeqChildState(seqState, index, parser) {
+	return getWrappedChildState(seqState, seqState.states[index], parser);
+}
+function updateSeqChildState(sourceState, index, childState, parser) {
+	return annotateFreshArray(sourceState.states, sourceState.states.map((state, stateIndex) => stateIndex === index ? getWrappedChildState(sourceState.states, childState, parser) : state));
+}
+function shouldAdvanceSeqBeforeParse(parser, parserState, initialParserState, currentContext, index, parsers) {
+	const token = currentContext.buffer[0];
+	if (token !== "--") {
+		const laterLeadingCandidates = leadingCandidatesAfter(parsers, index + 1);
+		if (!tokenMatchesLeadingName(token, laterLeadingCandidates)) return false;
+	}
+	if (!parserCanSkipAt(parser, parserState, currentContext.exec, index)) return false;
+	if (token === "--") return true;
+	if (currentContext.state.states[index] === initialParserState) {
+		const currentLeadingCandidates = sequenceLeadingCandidates([parser]);
+		return !tokenMatchesLeadingName(token, currentLeadingCandidates);
+	}
+	return !tokenMatchesLeadingName(token, collectRetainedLeadingCandidatesAtState(parser.usage, currentContext.state.states[index]));
+}
+function advanceSeqContext(currentContext, nextIndex, consumedTerminator) {
+	return {
+		...currentContext,
+		buffer: consumedTerminator ? currentContext.buffer.slice(1) : currentContext.buffer,
+		optionsTerminated: consumedTerminator ? true : currentContext.optionsTerminated,
+		state: createSeqState(currentContext.state, nextIndex, currentContext.state.states)
+	};
+}
+function updateSeqContextFromChildResult(currentContext, index, parser, result, nextIndex) {
+	const states = updateSeqChildState(currentContext.state, index, result.next.state, parser);
+	const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+	return {
+		...currentContext,
+		buffer: result.next.buffer,
+		optionsTerminated: result.next.optionsTerminated,
+		state: createSeqState(currentContext.state, nextIndex, states),
+		...mergedExec != null ? {
+			exec: mergedExec,
+			dependencyRegistry: mergedExec.dependencyRegistry
+		} : {}
+	};
+}
+function advanceSeqSuggestContextSync(context, parsers, initialStates) {
+	let currentContext = context;
+	while (currentContext.state.index < parsers.length) {
+		const index = currentContext.state.index;
+		const parser = parsers[index];
+		const parserState = getSeqChildState(currentContext.state, index, parser);
+		if (currentContext.buffer.length < 1) break;
+		if (shouldAdvanceSeqBeforeParse(parser, parserState, initialStates[index], currentContext, index, parsers)) {
+			const consumedTerminator = currentContext.buffer[0] === "--";
+			currentContext = advanceSeqContext(currentContext, index + 1, consumedTerminator);
+			continue;
+		}
+		const result = parser.parse(withChildContext$1(currentContext, index, parserState, parser));
+		if (!result.success) {
+			if (result.consumed > 0) break;
+			if (parserCanSkipAt(parser, parserState, currentContext.exec, index)) {
+				currentContext = advanceSeqContext(currentContext, index + 1, false);
+				continue;
+			}
+			break;
+		}
+		const nextIndex = result.consumed.length > 0 ? index : index + 1;
+		currentContext = updateSeqContextFromChildResult(currentContext, index, parser, result, nextIndex);
+	}
+	return currentContext;
+}
+async function advanceSeqSuggestContextAsync(context, parsers, initialStates) {
+	let currentContext = context;
+	while (currentContext.state.index < parsers.length) {
+		const index = currentContext.state.index;
+		const parser = parsers[index];
+		const parserState = getSeqChildState(currentContext.state, index, parser);
+		if (currentContext.buffer.length < 1) break;
+		if (shouldAdvanceSeqBeforeParse(parser, parserState, initialStates[index], currentContext, index, parsers)) {
+			const consumedTerminator = currentContext.buffer[0] === "--";
+			currentContext = advanceSeqContext(currentContext, index + 1, consumedTerminator);
+			continue;
+		}
+		const result = await parser.parse(withChildContext$1(currentContext, index, parserState, parser));
+		if (!result.success) {
+			if (result.consumed > 0) break;
+			if (parserCanSkipAt(parser, parserState, currentContext.exec, index)) {
+				currentContext = advanceSeqContext(currentContext, index + 1, false);
+				continue;
+			}
+			break;
+		}
+		const nextIndex = result.consumed.length > 0 ? index : index + 1;
+		currentContext = updateSeqContextFromChildResult(currentContext, index, parser, result, nextIndex);
+	}
+	return currentContext;
+}
+function createSeqComplete(parsers, combinedMode) {
+	const syncParsers = parsers;
+	return (state, exec) => dispatchByMode(combinedMode, () => {
+		const stateArray = annotateFreshArray(state, state.states);
+		const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+		const childExec = {
+			...exec,
+			dependencyRuntime: runtime
+		};
+		const pairs = buildIndexedParserPairs(syncParsers);
+		const stateRecord = createAnnotatedArrayStateRecord(stateArray);
+		const preCompleted = preCompleteAndRegisterDependencies(stateRecord, pairs, runtime.registry, childExec);
+		collectExplicitSourceValues(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(syncParsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
+		const phase3Exec = {
+			...childExec,
+			preCompletedByParser: void 0
+		};
+		const resolvedArray = resolveStateWithRuntime(stateArray, runtime);
+		const result = [];
+		const deferredKeys = /* @__PURE__ */ new Map();
+		let hasDeferred = false;
+		for (let i = 0; i < syncParsers.length; i++) {
+			const elementParser = syncParsers[i];
+			const preCompletedResult = preCompleted.get(String(i));
+			const valueResult = preCompletedResult !== void 0 ? unwrapCompleteResult(preCompletedResult) : unwrapCompleteResult(elementParser.complete(prepareStateForCompletion(getWrappedChildState(stateArray, resolvedArray[i], elementParser), elementParser), withChildExecPath(phase3Exec, i)));
+			if (!valueResult.success) return {
+				success: false,
+				error: valueResult.error
+			};
+			result[i] = valueResult.value;
+			if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(i, valueResult.deferredKeys);
+			else if (valueResult.value == null || typeof valueResult.value !== "object") deferredKeys.set(i, null);
+			else hasDeferred = true;
+		}
+		return {
+			success: true,
+			value: result,
+			...deferredKeys.size > 0 || hasDeferred ? {
+				deferred: true,
+				...deferredKeys.size > 0 ? { deferredKeys } : {}
+			} : {}
+		};
+	}, async () => {
+		const stateArray = annotateFreshArray(state, state.states);
+		const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+		const childExec = {
+			...exec,
+			dependencyRuntime: runtime
+		};
+		const pairs = buildIndexedParserPairs(parsers);
+		const stateRecord = createAnnotatedArrayStateRecord(stateArray);
+		const preCompleted = await preCompleteAndRegisterDependenciesAsync(stateRecord, pairs, runtime.registry, childExec);
+		await collectExplicitSourceValuesAsync(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(parsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
+		const phase3Exec = {
+			...childExec,
+			preCompletedByParser: void 0
+		};
+		const resolvedArray = await resolveStateWithRuntimeAsync(stateArray, runtime);
+		const result = [];
+		const deferredKeys = /* @__PURE__ */ new Map();
+		let hasDeferred = false;
+		for (let i = 0; i < parsers.length; i++) {
+			const elementParser = parsers[i];
+			const preCompletedResult = preCompleted.get(String(i));
+			const valueResult = preCompletedResult !== void 0 ? unwrapCompleteResult(preCompletedResult) : unwrapCompleteResult(await elementParser.complete(prepareStateForCompletion(getWrappedChildState(stateArray, resolvedArray[i], elementParser), elementParser), withChildExecPath(phase3Exec, i)));
+			if (!valueResult.success) return {
+				success: false,
+				error: valueResult.error
+			};
+			result[i] = valueResult.value;
+			if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(i, valueResult.deferredKeys);
+			else if (valueResult.value == null || typeof valueResult.value !== "object") deferredKeys.set(i, null);
+			else hasDeferred = true;
+		}
+		return {
+			success: true,
+			value: result,
+			...deferredKeys.size > 0 || hasDeferred ? {
+				deferred: true,
+				...deferredKeys.size > 0 ? { deferredKeys } : {}
+			} : {}
+		};
+	});
+}
 function suggestTupleSync(context, prefix, parsers) {
 	const suggestions = [];
 	const advanced = advanceTupleSuggestContextSync(context, parsers);
@@ -2678,6 +3128,10 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		priority: parsers.length > 0 ? Math.max(...parsers.map((p) => p.priority)) : 0,
 		initialState: parsers.map((parser) => parser.initialState),
+		canSkip(state, exec) {
+			const stateArray = state;
+			return parsers.every((parser, index) => parser.canSkip?.(getWrappedChildState(stateArray, stateArray[index], parser), withChildExecPath(exec, index)) === true);
+		},
 		parse(context) {
 			return dispatchByMode(combinedMode, () => parseSync(context), () => parseAsync(context));
 		},
@@ -2915,6 +3369,334 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	defineInheritedAnnotationParser(tupleParser);
 	return tupleParser;
 }
+function seq(...rawArgs) {
+	const label = typeof rawArgs[0] === "string" ? rawArgs[0] : void 0;
+	if (label != null) validateLabel(label);
+	const args = label == null ? rawArgs : rawArgs.slice(1);
+	const lastArg = args.at(-1);
+	const hasOptions = lastArg != null && !isParserLike(lastArg);
+	const options = hasOptions ? lastArg : {};
+	const parsers = hasOptions ? args.slice(0, -1) : args;
+	const combinedMode = parsers.some((p) => p.mode === "async") ? "async" : "sync";
+	const syncParsers = parsers;
+	if (!options.allowDuplicates) checkSequentialDuplicateOptionNames(parsers);
+	const initialState = createSeqState(void 0, 0, parsers.map((parser) => parser.initialState));
+	const withSeqConsumedDepth = (result, consumed) => ({
+		...result,
+		consumed: consumed.length + result.consumed
+	});
+	const parseSync = (context) => {
+		let currentContext = context;
+		const allConsumed = [];
+		while (currentContext.state.index < syncParsers.length) {
+			const index = currentContext.state.index;
+			const parser = syncParsers[index];
+			const parserState = getSeqChildState(currentContext.state, index, parser);
+			if (currentContext.buffer.length < 1) break;
+			if (shouldAdvanceSeqBeforeParse(parser, parserState, initialState.states[index], currentContext, index, syncParsers)) {
+				const consumedTerminator = currentContext.buffer[0] === "--";
+				if (consumedTerminator) allConsumed.push("--");
+				currentContext = advanceSeqContext(currentContext, index + 1, consumedTerminator);
+				continue;
+			}
+			const result = parser.parse(withChildContext$1(currentContext, index, parserState, parser));
+			if (!result.success) {
+				if (result.consumed > 0) return withSeqConsumedDepth(result, allConsumed);
+				if (!parserCanSkipAt(parser, parserState, currentContext.exec, index)) return withSeqConsumedDepth(result, allConsumed);
+				currentContext = advanceSeqContext(currentContext, index + 1, false);
+				continue;
+			}
+			const states = updateSeqChildState(currentContext.state, index, result.next.state, parser);
+			const nextIndex = result.consumed.length > 0 ? index : index + 1;
+			const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+			currentContext = {
+				...currentContext,
+				buffer: result.next.buffer,
+				optionsTerminated: result.next.optionsTerminated,
+				state: createSeqState(currentContext.state, nextIndex, states),
+				...mergedExec != null ? {
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
+			};
+			allConsumed.push(...result.consumed);
+		}
+		return {
+			success: true,
+			next: currentContext,
+			consumed: allConsumed
+		};
+	};
+	const parseAsync = async (context) => {
+		let currentContext = context;
+		const allConsumed = [];
+		while (currentContext.state.index < parsers.length) {
+			const index = currentContext.state.index;
+			const parser = parsers[index];
+			const parserState = getSeqChildState(currentContext.state, index, parser);
+			if (currentContext.buffer.length < 1) break;
+			if (shouldAdvanceSeqBeforeParse(parser, parserState, initialState.states[index], currentContext, index, parsers)) {
+				const consumedTerminator = currentContext.buffer[0] === "--";
+				if (consumedTerminator) allConsumed.push("--");
+				currentContext = advanceSeqContext(currentContext, index + 1, consumedTerminator);
+				continue;
+			}
+			const result = await parser.parse(withChildContext$1(currentContext, index, parserState, parser));
+			if (!result.success) {
+				if (result.consumed > 0) return withSeqConsumedDepth(result, allConsumed);
+				if (!parserCanSkipAt(parser, parserState, currentContext.exec, index)) return withSeqConsumedDepth(result, allConsumed);
+				currentContext = advanceSeqContext(currentContext, index + 1, false);
+				continue;
+			}
+			const states = updateSeqChildState(currentContext.state, index, result.next.state, parser);
+			const nextIndex = result.consumed.length > 0 ? index : index + 1;
+			const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+			currentContext = {
+				...currentContext,
+				buffer: result.next.buffer,
+				optionsTerminated: result.next.optionsTerminated,
+				state: createSeqState(currentContext.state, nextIndex, states),
+				...mergedExec != null ? {
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
+			};
+			allConsumed.push(...result.consumed);
+		}
+		return {
+			success: true,
+			next: currentContext,
+			consumed: allConsumed
+		};
+	};
+	const leadingNames = sequenceLeadingNames(parsers);
+	const seqParser = {
+		mode: combinedMode,
+		$valueType: [],
+		$stateType: [],
+		[fieldParsersKey]: parsers.map((parser, index) => [String(index), parser]),
+		usage: [{
+			type: "sequence",
+			terms: parsers.flatMap((parser) => parser.usage)
+		}],
+		leadingNames,
+		acceptingAnyToken: sequenceAcceptingAnyToken(parsers),
+		priority: sequencePriority(parsers),
+		initialState,
+		canSkip(state, exec) {
+			for (let i = state.index; i < parsers.length; i++) {
+				const parser = parsers[i];
+				if (parser.canSkip?.(getSeqChildState(state, i, parser), withChildExecPath(exec, i)) !== true) return false;
+			}
+			return true;
+		},
+		parse(context) {
+			return dispatchByMode(combinedMode, () => parseSync(context), () => parseAsync(context));
+		},
+		complete: void 0,
+		[extractPhase2SeedKey](state, exec) {
+			return dispatchByMode(combinedMode, () => {
+				const stateArray = state.states;
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(seqParser.usage, exec, runtime);
+				const pairs = buildIndexedParserPairs(syncParsers);
+				const stateRecord = createAnnotatedArrayStateRecord(stateArray);
+				const preCompleted = preCompleteAndRegisterDependencies(stateRecord, pairs, runtime.registry, childExec);
+				collectExplicitSourceValues(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(syncParsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const resolvedArray = resolveStateWithRuntime(stateArray, runtime);
+				const result = [];
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (let i = 0; i < syncParsers.length; i++) {
+					const elementParser = syncParsers[i];
+					const childExec$1 = withChildExecPath(phase3Exec, i);
+					const preCompletedResult = preCompleted.get(String(i));
+					const seed = preCompletedResult !== void 0 ? reusePreCompletedPhase2Seed(elementParser, prepareStateForCompletion(resolvedArray[i], elementParser), preCompletedResult, childExec$1) : completeOrExtractPhase2Seed(elementParser, prepareStateForCompletion(resolvedArray[i], elementParser), childExec$1);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					result[i] = seed.value;
+					if (seed.deferred) if (seed.deferredKeys) deferredKeys.set(i, seed.deferredKeys);
+					else if (seed.value == null || typeof seed.value !== "object") deferredKeys.set(i, null);
+					else hasDeferred = true;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: result,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			}, async () => {
+				const stateArray = state.states;
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(seqParser.usage, exec, runtime);
+				const pairs = buildIndexedParserPairs(parsers);
+				const stateRecord = createAnnotatedArrayStateRecord(stateArray);
+				const preCompleted = await preCompleteAndRegisterDependenciesAsync(stateRecord, pairs, runtime.registry, childExec);
+				await collectExplicitSourceValuesAsync(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(parsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const resolvedArray = await resolveStateWithRuntimeAsync(stateArray, runtime);
+				const result = [];
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (let i = 0; i < parsers.length; i++) {
+					const elementParser = parsers[i];
+					const childExec$1 = withChildExecPath(phase3Exec, i);
+					const preCompletedResult = preCompleted.get(String(i));
+					const seed = preCompletedResult !== void 0 ? await reusePreCompletedPhase2SeedAsync(elementParser, prepareStateForCompletion(resolvedArray[i], elementParser), preCompletedResult, childExec$1) : await completeOrExtractPhase2Seed(elementParser, prepareStateForCompletion(resolvedArray[i], elementParser), childExec$1);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					result[i] = seed.value;
+					if (seed.deferred) if (seed.deferredKeys) deferredKeys.set(i, seed.deferredKeys);
+					else if (seed.value == null || typeof seed.value !== "object") deferredKeys.set(i, null);
+					else hasDeferred = true;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: result,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			});
+		},
+		suggest(context, prefix) {
+			return dispatchIterableByMode(combinedMode, () => {
+				const suggestions = [];
+				const advancedContext = advanceSeqSuggestContextSync(context, syncParsers, initialState.states);
+				const runtime = createDependencyRuntimeContext(advancedContext.dependencyRegistry?.clone());
+				const state = advancedContext.state;
+				const stateArray = state.states;
+				const nodes = buildSuggestRuntimeNodesFromArray(syncParsers, stateArray, advancedContext.exec?.path);
+				collectExplicitSourceValues(nodes, runtime);
+				fillMissingSourceDefaults(nodes, runtime);
+				collectSourcesFromState(stateArray, runtime);
+				completeDependencySourceDefaults({
+					...advancedContext,
+					state: createAnnotatedArrayStateRecord(stateArray)
+				}, buildIndexedParserPairs(syncParsers), runtime.registry, advancedContext.exec);
+				const contextWithRegistry = {
+					...advancedContext,
+					dependencyRegistry: runtime.registry,
+					...advancedContext.exec != null ? { exec: {
+						...advancedContext.exec,
+						dependencyRuntime: runtime,
+						dependencyRegistry: runtime.registry
+					} } : {}
+				};
+				for (let i = state.index; i < syncParsers.length; i++) {
+					const parser = syncParsers[i];
+					const parserState = getSeqChildState(state, i, parser);
+					suggestions.push(...parser.suggest(withChildContext$1(contextWithRegistry, i, parserState, parser), prefix));
+					if (parser.canSkip?.(parserState, withChildExecPath(contextWithRegistry.exec, i)) !== true) break;
+				}
+				return deduplicateSuggestions(suggestions);
+			}, async function* () {
+				const suggestions = [];
+				const advancedContext = await advanceSeqSuggestContextAsync(context, parsers, initialState.states);
+				const runtime = createDependencyRuntimeContext(advancedContext.dependencyRegistry?.clone());
+				const state = advancedContext.state;
+				const stateArray = state.states;
+				const nodes = buildSuggestRuntimeNodesFromArray(parsers, stateArray, advancedContext.exec?.path);
+				await collectExplicitSourceValuesAsync(nodes, runtime);
+				await fillMissingSourceDefaultsAsync(nodes, runtime);
+				collectSourcesFromState(stateArray, runtime);
+				await completeDependencySourceDefaultsAsync({
+					...advancedContext,
+					state: createAnnotatedArrayStateRecord(stateArray)
+				}, buildIndexedParserPairs(parsers), runtime.registry, advancedContext.exec);
+				const contextWithRegistry = {
+					...advancedContext,
+					dependencyRegistry: runtime.registry,
+					...advancedContext.exec != null ? { exec: {
+						...advancedContext.exec,
+						dependencyRuntime: runtime,
+						dependencyRegistry: runtime.registry
+					} } : {}
+				};
+				for (let i = state.index; i < parsers.length; i++) {
+					const parser = parsers[i];
+					const parserState = getSeqChildState(state, i, parser);
+					const parserSuggestions = parser.suggest(withChildContext$1(contextWithRegistry, i, parserState, parser), prefix);
+					if (parser.mode === "async") for await (const suggestion of parserSuggestions) suggestions.push(suggestion);
+					else suggestions.push(...parserSuggestions);
+					if (parser.canSkip?.(parserState, withChildExecPath(contextWithRegistry.exec, i)) !== true) break;
+				}
+				yield* deduplicateSuggestions(suggestions);
+			});
+		},
+		getDocFragments(state, defaultValue) {
+			const fragments = syncParsers.flatMap((parser, index) => {
+				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
+					kind: "available",
+					state: state.state.states[index]
+				};
+				return parser.getDocFragments(indexState, defaultValue?.[index]).fragments;
+			});
+			const entries = fragments.filter((d) => d.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			sections.push({
+				title: label,
+				entries
+			});
+			return { fragments: sections.map((s) => ({
+				...s,
+				type: "section"
+			})) };
+		},
+		[Symbol.for("Deno.customInspect")]() {
+			const parsersStr = parsers.length === 1 ? "1 parser" : `${parsers.length} parsers`;
+			return label == null ? `seq(${parsersStr})` : `seq(${JSON.stringify(label)}, ${parsersStr})`;
+		}
+	};
+	Object.defineProperty(seqParser, "complete", {
+		value: createSeqComplete(parsers, combinedMode),
+		configurable: true,
+		enumerable: true
+	});
+	const normalizers = [];
+	for (let i = 0; i < parsers.length; i++) {
+		const parser = parsers[i];
+		if (typeof parser.normalizeValue === "function") normalizers.push([i, parser.normalizeValue.bind(parser)]);
+	}
+	if (normalizers.length > 0) Object.defineProperty(seqParser, "normalizeValue", {
+		value(arr) {
+			if (!Array.isArray(arr)) return arr;
+			let changed = false;
+			let result;
+			for (const [index, normalize] of normalizers) if (index < arr.length && Object.hasOwn(arr, index)) try {
+				const original = arr[index];
+				const normalized = normalize(original);
+				if (normalized !== original) {
+					result ??= [...arr];
+					result[index] = normalized;
+					changed = true;
+				}
+			} catch {}
+			return changed ? result : arr;
+		},
+		configurable: true,
+		enumerable: false
+	});
+	defineInheritedAnnotationParser(seqParser);
+	return seqParser;
+}
 function merge(...args) {
 	const label = typeof args[0] === "string" ? args[0] : void 0;
 	if (label != null) validateLabel(label);
@@ -2936,6 +3718,7 @@ function merge(...args) {
 	const syncSorted = syncWithIndex.toSorted(([a], [b]) => b.priority - a.priority);
 	const syncParsers = syncSorted.map(([p]) => p);
 	if (!options.allowDuplicates) checkDuplicateOptionNames(sorted.map(([parser, originalIndex]) => [String(originalIndex), parser.usage]));
+	checkDuplicateReachableLeadingCommandNames(sorted.map(([parser, originalIndex]) => [String(originalIndex), parser]));
 	const mergedFieldParsers = collectChildFieldParsers(parsers);
 	const duplicateOutputFieldNames = collectDuplicateFieldNames(mergedFieldParsers);
 	const parserStateKey = (index) => `__parser_${index}`;
@@ -2947,23 +3730,24 @@ function merge(...args) {
 		if (parser.initialState === void 0) initialState[parserStateKey(i)] = void 0;
 		else if (parser.initialState && typeof parser.initialState === "object") for (const field in parser.initialState) initialState[field] = parser.initialState[field];
 	}
-	const extractParserState = (parser, context, index) => {
+	const extractParserStateFromState = (parser, state, index) => {
 		if (parser.initialState === void 0) {
 			const key = parserStateKey(index);
-			if (context.state && typeof context.state === "object" && key in context.state) return context.state[key];
+			if (state && typeof state === "object" && key in state) return state[key];
 			return void 0;
 		} else if (parser.initialState && typeof parser.initialState === "object") {
 			const localStateKey = localObjectStateKey(index);
-			if (shouldPreserveLocalChildState(parser) && context.state && typeof context.state === "object" && localStateKey in context.state) return context.state[localStateKey];
-			if (context.state && typeof context.state === "object") {
+			if (shouldPreserveLocalChildState(parser) && state && typeof state === "object" && localStateKey in state) return state[localStateKey];
+			if (state && typeof state === "object") {
 				const extractedState = {};
-				for (const field in parser.initialState) extractedState[field] = field in context.state ? context.state[field] : parser.initialState[field];
+				for (const field in parser.initialState) extractedState[field] = field in state ? state[field] : parser.initialState[field];
 				return extractedState;
 			}
 			return parser.initialState;
 		}
 		return parser.initialState;
 	};
+	const extractParserState = (parser, context, index) => extractParserStateFromState(parser, context.state, index);
 	const mergeResultState = (parser, context, parserState, result, index) => {
 		if (parser.initialState === void 0) {
 			const key = parserStateKey(index);
@@ -3088,6 +3872,12 @@ function merge(...args) {
 		leadingNames: sharedBufferLeadingNames(parsers),
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState,
+		canSkip(state, exec) {
+			return parsers.every((parser, index) => {
+				const parserState = extractParserStateFromState(parser, state, index);
+				return parser.canSkip?.(getWrappedChildState(state, parserState, parser), withChildExecPath(exec, index)) === true;
+			});
+		},
 		parse(context) {
 			if (isAsync) return parseAsync(context);
 			return parseSync(context);
@@ -4033,6 +4823,10 @@ function concat(...parsers) {
 		leadingNames: sharedBufferLeadingNames(parsers),
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState,
+		canSkip(state, exec) {
+			const stateArray = state;
+			return parsers.every((parser, index) => parser.canSkip?.(getWrappedChildState(stateArray, stateArray[index], parser), withChildExecPath(exec, index)) === true);
+		},
 		parse(context) {
 			if (isAsync) return parseAsync(context);
 			return parseSync(context);
@@ -4181,6 +4975,7 @@ function group(label, parser, options = {}) {
 		initialState: parser.initialState,
 		...fieldParsersKey in parser ? { [fieldParsersKey]: parser[fieldParsersKey] } : {},
 		...typeof parser.shouldDeferCompletion === "function" ? { shouldDeferCompletion: parser.shouldDeferCompletion.bind(parser) } : {},
+		...typeof parser.canSkip === "function" ? { canSkip: parser.canSkip.bind(parser) } : {},
 		getSuggestRuntimeNodes(state, path) {
 			return parser.getSuggestRuntimeNodes?.(state, path) ?? (parser.dependencyMetadata?.source != null ? [{
 				path,
@@ -4338,6 +5133,10 @@ function conditional(discriminator, branches, defaultBranch, options) {
 			...term,
 			terms: appendLiteralToUsage(term.terms, literalValue)
 		});
+		else if (term.type === "sequence") result.push({
+			...term,
+			terms: appendLiteralToUsage(term.terms, literalValue)
+		});
 		else if (term.type === "exclusive") result.push({
 			...term,
 			terms: term.terms.map((t) => appendLiteralToUsage(t, literalValue))
@@ -5225,4 +6024,4 @@ function conditional(discriminator, branches, defaultBranch, options) {
 }
 
 //#endregion
-export { DuplicateOptionError, concat, conditional, group, longestMatch, merge, object, or, tuple };
+export { DuplicateOptionError, concat, conditional, group, longestMatch, merge, object, or, seq, tuple };