@optique/core 1.0.5 → 1.0.7

package/dist/constructs.js

@@ -6,7 +6,7 @@ import { deduplicateDocFragments } from "./doc.js";
 import { dispatchByMode, dispatchIterableByMode } from "./internal/mode-dispatch.js";
 import { createDependencySourceState, dependencyId, isDependencySourceState, isPendingDependencySourceState, isWrappedDependencySource, wrappedDependencySourceMarker } from "./internal/dependency.js";
 import { buildRuntimeNodesFromArray, buildRuntimeNodesFromPairs, collectExplicitSourceValues, collectExplicitSourceValuesAsync, collectSourcesFromState, createDependencyRuntimeContext, fillMissingSourceDefaults, fillMissingSourceDefaultsAsync, resolveStateWithRuntime, resolveStateWithRuntimeAsync } from "./dependency-runtime.js";
-import { defineInheritedAnnotationParser, getParserSuggestRuntimeNodes, unmatchedNonCliDependencySourceStateMarker } from "./internal/parser.js";
+import { defineInheritedAnnotationParser, defineParseLanes, getOwnParseLanes, getParserSuggestRuntimeNodes, unmatchedNonCliDependencySourceStateMarker } from "./internal/parser.js";
 import { annotationViewTargets, getWrappedChildParseState, getWrappedChildState, reconcileObjectChildState, unwrapAnnotationView } from "./annotation-state.js";
 import { mergeChildExec, withChildContext, withChildExecPath } from "./execution-context.js";
 import { completeOrExtractPhase2Seed, extractPhase2Seed, extractPhase2SeedKey, phase2SeedFromValueResult } from "./phase2-seed.js";
@@ -77,8 +77,8 @@ function unionLeadingNames(parsers) {
 * Computes `leadingNames` for shared-buffer compositions (`tuple()`,
 * `object()`, `merge()`, `concat()`).
 *
-* Children are processed in descending priority order (matching the
-* round-robin parse loop).  Once a child with `acceptingAnyToken` is
+* Sources are processed in descending priority order (matching the
+* round-robin parse loop).  Once a source with `acceptingAnyToken` is
 * encountered, no lower-priority children can match at position 0, so
 * their names are excluded.
 */
@@ -1448,6 +1448,33 @@ function longestMatch(...args) {
 	return multiResult;
 }
 /**
+* Creates the initial parse error shared by object-like combinators.
+* @param context The current parser context.
+* @param noMatchContext The kinds of input accepted by the combinator.
+* @param errors Optional custom error formatters.
+* @returns A zero-consumption parse error.
+*/
+function createObjectLikeInitialError(context, noMatchContext, errors) {
+	if (context.buffer.length < 1) {
+		const customEndOfInput = errors?.endOfInput;
+		return {
+			consumed: 0,
+			error: customEndOfInput ? typeof customEndOfInput === "function" ? customEndOfInput(noMatchContext) : customEndOfInput : generateNoMatchError(noMatchContext)
+		};
+	}
+	const token = context.buffer[0];
+	const customMessage = errors?.unexpectedInput;
+	if (customMessage) return {
+		consumed: 0,
+		error: typeof customMessage === "function" ? customMessage(token) : customMessage
+	};
+	const baseError = message`Unexpected option or argument: ${token}.`;
+	return {
+		consumed: 0,
+		error: createErrorWithSuggestions(baseError, token, context.usage, "both", errors?.suggestions)
+	};
+}
+/**
 * Internal sync helper for object suggest functionality.
 * @internal
 */
@@ -1839,19 +1866,53 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	if (!options.allowDuplicates) checkDuplicateOptionNames(parserPairs.map(([field, parser]) => [field, parser.usage]));
 	const noMatchContext = analyzeNoMatchContext(parserKeys.map((k) => parsers[k]));
 	const combinedMode = parserKeys.some((k) => parsers[k].mode === "async") ? "async" : "sync";
-	const getInitialError = (context) => ({
-		consumed: 0,
-		error: context.buffer.length > 0 ? (() => {
-			const token = context.buffer[0];
-			const customMessage = options.errors?.unexpectedInput;
-			if (customMessage) return typeof customMessage === "function" ? customMessage(token) : customMessage;
-			const baseError = message`Unexpected option or argument: ${token}.`;
-			return createErrorWithSuggestions(baseError, token, context.usage, "both", options.errors?.suggestions);
-		})() : (() => {
-			const customEndOfInput = options.errors?.endOfInput;
-			return customEndOfInput ? typeof customEndOfInput === "function" ? customEndOfInput(noMatchContext) : customEndOfInput : generateNoMatchError(noMatchContext);
-		})()
-	});
+	const getInitialError = (context) => createObjectLikeInitialError(context, noMatchContext, options.errors);
+	const adaptFieldLaneResult = (context, field, parser, fieldState, result) => {
+		if (!result.success) return result;
+		if (result.consumed.length === 0 && result.next.state === fieldState) return {
+			success: true,
+			next: context,
+			consumed: []
+		};
+		const mergedExec = mergeChildExec(context.exec, result.next.exec);
+		const nextState = result.next.state === fieldState ? context.state : {
+			...context.state,
+			[field]: getWrappedChildState(context.state, result.next.state, parser)
+		};
+		return {
+			success: true,
+			next: {
+				...context,
+				buffer: result.next.buffer,
+				optionsTerminated: result.next.optionsTerminated,
+				state: nextState,
+				...mergedExec != null ? {
+					trace: mergedExec.trace,
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
+			},
+			consumed: result.consumed
+		};
+	};
+	const objectZeroConsumptionGroup = {};
+	const objectParseLanes = parserPairs.map(([field, parser]) => ({
+		priority: parser.priority,
+		zeroConsumptionGroup: objectZeroConsumptionGroup,
+		settlesZeroConsumption: false,
+		leadingNames: parser.leadingNames,
+		acceptingAnyToken: parser.acceptingAnyToken,
+		parse(context) {
+			const fieldState = createFieldStateGetter(context.state, getObjectParseChildState)(field, parser);
+			return dispatchByMode(combinedMode, () => {
+				const result = parser.parse(withChildContext$1(context, field, fieldState, parser));
+				return adaptFieldLaneResult(context, field, parser, fieldState, result);
+			}, async () => {
+				const result = await parser.parse(withChildContext$1(context, field, fieldState, parser));
+				return adaptFieldLaneResult(context, field, parser, fieldState, result);
+			});
+		}
+	}));
 	const parseSync = (context) => {
 		let error = getInitialError(context);
 		let currentContext = context;
@@ -2345,6 +2406,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		configurable: true,
 		enumerable: false
 	});
+	defineParseLanes(objectParser, objectParseLanes);
 	defineInheritedAnnotationParser(objectParser);
 	return objectParser;
 }
@@ -3000,6 +3062,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]));
+	const noMatchContext = analyzeNoMatchContext(rawParsers);
 	const mergedFieldParsers = collectChildFieldParsers(parsers);
 	const duplicateOutputFieldNames = collectDuplicateFieldNames(mergedFieldParsers);
 	const parserStateKey = (index) => `__parser_${index}`;
@@ -3011,17 +3074,17 @@ 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 extractParserState = (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;
@@ -3051,12 +3114,145 @@ function merge(...args) {
 			[localObjectStateKey(index)]: result.next.state
 		};
 	};
-	const parseSync = (context) => {
+	const adaptMergeLaneResult = (parser, context, parserState, parsedState, result, index) => {
+		if (!result.success) return result;
+		const mergedExec = mergeChildExec(context.exec, result.next.exec);
+		const newState = result.next.state === parsedState ? context.state : mergeResultState(parser, context, parserState, result, index);
+		return {
+			success: true,
+			next: {
+				...context,
+				buffer: result.next.buffer,
+				optionsTerminated: result.next.optionsTerminated,
+				state: newState,
+				...mergedExec != null ? {
+					trace: mergedExec.trace,
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
+			},
+			consumed: result.consumed
+		};
+	};
+	const childrenInDeclarationOrder = sorted.map(([parser, originalIndex], sortedIndex) => ({
+		parser,
+		originalIndex,
+		sortedIndex
+	})).toSorted((a, b) => a.originalIndex - b.originalIndex);
+	const mergeParseLanes = childrenInDeclarationOrder.flatMap(({ parser, sortedIndex }) => {
+		const occurrenceConsumptionGroups = /* @__PURE__ */ new WeakMap();
+		const occurrenceZeroConsumptionGroups = /* @__PURE__ */ new WeakMap();
+		const scopeConsumptionGroup = (group$1) => {
+			const existing = occurrenceConsumptionGroups.get(group$1);
+			if (existing != null) return existing;
+			const scoped = {};
+			occurrenceConsumptionGroups.set(group$1, scoped);
+			return scoped;
+		};
+		const childLanes = getOwnParseLanes(parser);
+		const lanes = childLanes ?? [{
+			priority: parser.priority,
+			leadingNames: parser.leadingNames,
+			acceptingAnyToken: parser.acceptingAnyToken,
+			parse(context) {
+				return parser.parse(context);
+			}
+		}];
+		return lanes.map((lane) => ({
+			priority: lane.priority,
+			zeroConsumptionGroup: (() => {
+				const group$1 = lane.zeroConsumptionGroup ?? lane;
+				const existing = occurrenceZeroConsumptionGroups.get(group$1);
+				if (existing != null) return existing;
+				const scoped = {};
+				occurrenceZeroConsumptionGroups.set(group$1, scoped);
+				return scoped;
+			})(),
+			settlesZeroConsumption: lane.settlesZeroConsumption,
+			leadingNames: lane.leadingNames,
+			acceptingAnyToken: lane.acceptingAnyToken,
+			requiredConsumptionGroups: lane.requiredConsumptionGroups?.map((group$1) => ({
+				id: scopeConsumptionGroup(group$1.id),
+				...group$1.isActive == null ? {} : { isActive(state) {
+					if (state == null || typeof state !== "object") return false;
+					const parserState = extractParserState(parser, state, sortedIndex);
+					return group$1.isActive?.(parserState) ?? true;
+				} }
+			})),
+			parse(context) {
+				const parserState = extractParserState(parser, context.state, sortedIndex);
+				const childContext = withChildContext$1(context, sortedIndex, parserState, parser);
+				return dispatchByMode(combinedMode, () => {
+					const result = lane.parse(childContext);
+					return adaptMergeLaneResult(parser, context, parserState, childContext.state, result, sortedIndex);
+				}, async () => {
+					const result = await lane.parse(childContext);
+					return adaptMergeLaneResult(parser, context, parserState, childContext.state, result, sortedIndex);
+				});
+			}
+		}));
+	}).toSorted((a, b) => b.priority - a.priority);
+	const settleZeroConsumptionLanes = (context, laneResults) => {
+		const groups = /* @__PURE__ */ new Map();
+		for (const lane of mergeParseLanes) {
+			const group$1 = lane.zeroConsumptionGroup ?? lane;
+			const groupedLanes = groups.get(group$1);
+			if (groupedLanes == null) groups.set(group$1, [lane]);
+			else groupedLanes.push(lane);
+		}
+		const settledGroups = [];
+		for (const groupedLanes of groups.values()) {
+			const groupSucceeded = groupedLanes.every((lane) => {
+				const result = laneResults.get(lane);
+				return lane.settlesZeroConsumption !== false && result?.success === true && result.consumed.length === 0 && (lane.requiredConsumptionGroups?.length ?? 0) === 0;
+			});
+			if (!groupSucceeded) return null;
+			settledGroups.push(groupedLanes);
+		}
+		let settledContext = context;
+		for (const groupedLanes of settledGroups) for (const lane of groupedLanes) {
+			const result = laneResults.get(lane);
+			if (result?.success !== true) continue;
+			const originalState = context.state;
+			const resultState = result.next.state;
+			const nextState = { ...settledContext.state };
+			const stateKeys = new Set([...Reflect.ownKeys(originalState), ...Reflect.ownKeys(resultState)]);
+			for (const key of stateKeys) {
+				const originalHasKey = Object.hasOwn(originalState, key);
+				const resultHasKey = Object.hasOwn(resultState, key);
+				if (originalHasKey === resultHasKey && originalState[key] === resultState[key]) continue;
+				if (resultHasKey) nextState[key] = resultState[key];
+				else delete nextState[key];
+			}
+			const mergedExec = mergeChildExec(settledContext.exec, result.next.exec);
+			settledContext = {
+				...settledContext,
+				buffer: result.next.buffer,
+				optionsTerminated: result.next.optionsTerminated,
+				state: nextState,
+				...mergedExec != null ? {
+					trace: mergedExec.trace,
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
+			};
+		}
+		return {
+			success: true,
+			next: settledContext,
+			consumed: []
+		};
+	};
+	const canTryPositionalLaneAfterFailure = (lane, context) => {
+		const token = context.buffer[0];
+		return token != null && (context.optionsTerminated || !token.startsWith("-")) && (lane.acceptingAnyToken || lane.leadingNames.has(token));
+	};
+	const parseChildrenSync = (context) => {
 		let currentContext = context;
 		let zeroConsumedSuccess = null;
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
-			const parserState = extractParserState(parser, currentContext, i);
+			const parserState = extractParserState(parser, currentContext.state, i);
 			const result = parser.parse(withChildContext$1(currentContext, i, parserState, parser));
 			if (result.success) {
 				const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
@@ -3092,16 +3288,15 @@ function merge(...args) {
 		};
 		return {
 			success: false,
-			consumed: 0,
-			error: message`No matching option or argument found.`
+			...createObjectLikeInitialError(context, noMatchContext)
 		};
 	};
-	const parseAsync = async (context) => {
+	const parseChildrenAsync = async (context) => {
 		let currentContext = context;
 		let zeroConsumedSuccess = null;
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
-			const parserState = extractParserState(parser, currentContext, i);
+			const parserState = extractParserState(parser, currentContext.state, i);
 			const resultOrPromise = parser.parse(withChildContext$1(currentContext, i, parserState, parser));
 			const result = await resultOrPromise;
 			if (result.success) {
@@ -3138,8 +3333,133 @@ function merge(...args) {
 		};
 		return {
 			success: false,
-			consumed: 0,
-			error: message`No matching option or argument found.`
+			...createObjectLikeInitialError(context, noMatchContext)
+		};
+	};
+	const parseSync = (context) => {
+		let currentContext = context;
+		let error = createObjectLikeInitialError(context, noMatchContext);
+		const allConsumed = [];
+		const consumedLanes = /* @__PURE__ */ new Set();
+		const consumedGroups = /* @__PURE__ */ new Set();
+		const laneResults = /* @__PURE__ */ new Map();
+		let attemptedLane = false;
+		let madeProgress = true;
+		while (madeProgress && currentContext.buffer.length > 0) {
+			madeProgress = false;
+			let consumingError = null;
+			for (const lane of mergeParseLanes) {
+				if (consumingError != null && lane.priority < consumingError.priority) {
+					if (!canTryPositionalLaneAfterFailure(lane, currentContext)) continue;
+				}
+				attemptedLane = true;
+				const result = lane.parse(currentContext);
+				laneResults.set(lane, result);
+				if (result.success && result.consumed.length > 0) {
+					currentContext = result.next;
+					allConsumed.push(...result.consumed);
+					consumedLanes.add(lane);
+					for (const group$1 of lane.requiredConsumptionGroups ?? []) if (group$1.isActive?.(result.next.state) !== false) consumedGroups.add(group$1.id);
+					madeProgress = true;
+					break;
+				}
+				if (!result.success) {
+					if (result.consumed > 0 && consumingError == null) consumingError = {
+						priority: lane.priority,
+						result
+					};
+					if (error.consumed < result.consumed) error = result;
+				}
+			}
+			if (!madeProgress && consumingError != null && allConsumed.length === 0) return consumingError.result;
+		}
+		if (allConsumed.length === 0) {
+			if (attemptedLane) {
+				const settled = settleZeroConsumptionLanes(context, laneResults);
+				return settled ?? {
+					...error,
+					success: false
+				};
+			}
+			const fallback = parseChildrenSync(context);
+			if (!fallback.success && fallback.consumed < error.consumed) return {
+				...error,
+				success: false
+			};
+			return fallback;
+		}
+		for (const lane of mergeParseLanes) {
+			if (consumedLanes.has(lane) || lane.leadingNames.size > 0 || lane.acceptingAnyToken || lane.requiredConsumptionGroups?.some((group$1) => !consumedGroups.has(group$1.id)) === true) continue;
+			const result = lane.parse(currentContext);
+			if (result.success && result.consumed.length === 0 && result.next.state !== currentContext.state) currentContext = result.next;
+		}
+		return {
+			success: true,
+			next: currentContext,
+			consumed: allConsumed
+		};
+	};
+	const parseAsync = async (context) => {
+		let currentContext = context;
+		let error = createObjectLikeInitialError(context, noMatchContext);
+		const allConsumed = [];
+		const consumedLanes = /* @__PURE__ */ new Set();
+		const consumedGroups = /* @__PURE__ */ new Set();
+		const laneResults = /* @__PURE__ */ new Map();
+		let attemptedLane = false;
+		let madeProgress = true;
+		while (madeProgress && currentContext.buffer.length > 0) {
+			madeProgress = false;
+			let consumingError = null;
+			for (const lane of mergeParseLanes) {
+				if (consumingError != null && lane.priority < consumingError.priority) {
+					if (!canTryPositionalLaneAfterFailure(lane, currentContext)) continue;
+				}
+				attemptedLane = true;
+				const result = await lane.parse(currentContext);
+				laneResults.set(lane, result);
+				if (result.success && result.consumed.length > 0) {
+					currentContext = result.next;
+					allConsumed.push(...result.consumed);
+					consumedLanes.add(lane);
+					for (const group$1 of lane.requiredConsumptionGroups ?? []) if (group$1.isActive?.(result.next.state) !== false) consumedGroups.add(group$1.id);
+					madeProgress = true;
+					break;
+				}
+				if (!result.success) {
+					if (result.consumed > 0 && consumingError == null) consumingError = {
+						priority: lane.priority,
+						result
+					};
+					if (error.consumed < result.consumed) error = result;
+				}
+			}
+			if (!madeProgress && consumingError != null && allConsumed.length === 0) return consumingError.result;
+		}
+		if (allConsumed.length === 0) {
+			if (attemptedLane) {
+				const settled = settleZeroConsumptionLanes(context, laneResults);
+				return settled ?? {
+					...error,
+					success: false
+				};
+			}
+			const fallback = await parseChildrenAsync(context);
+			if (!fallback.success && fallback.consumed < error.consumed) return {
+				...error,
+				success: false
+			};
+			return fallback;
+		}
+		for (const lane of mergeParseLanes) {
+			if (consumedLanes.has(lane) || lane.leadingNames.size > 0 || lane.acceptingAnyToken || lane.requiredConsumptionGroups?.some((group$1) => !consumedGroups.has(group$1.id)) === true) continue;
+			const result = await lane.parse(currentContext);
+			if (result.success && result.consumed.length === 0 && result.next.state !== currentContext.state) currentContext = result.next;
+		}
+		return {
+			success: true,
+			next: currentContext,
+			consumed: allConsumed
 		};
 	};
 	const mergeParser = {
@@ -3147,10 +3467,10 @@ function merge(...args) {
 		$valueType: [],
 		$stateType: [],
 		[fieldParsersKey]: mergedFieldParsers,
-		priority: Math.max(...parsers.map((p) => p.priority)),
+		priority: Math.max(...mergeParseLanes.map((lane) => lane.priority)),
 		usage: applyHiddenToUsage(parsers.flatMap((p) => p.usage), options.hidden),
-		leadingNames: sharedBufferLeadingNames(parsers),
-		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
+		leadingNames: sharedBufferLeadingNames(mergeParseLanes),
+		acceptingAnyToken: mergeParseLanes.some((lane) => lane.acceptingAnyToken),
 		initialState,
 		parse(context) {
 			if (isAsync) return parseAsync(context);
@@ -3619,6 +3939,7 @@ function merge(...args) {
 			};
 		}
 	};
+	defineParseLanes(mergeParser, mergeParseLanes);
 	defineInheritedAnnotationParser(mergeParser);
 	return mergeParser;
 }
@@ -4296,6 +4617,7 @@ function group(label, parser, options = {}) {
 			};
 		}
 	};
+	defineParseLanes(groupParser, getOwnParseLanes(parser));
 	Object.defineProperty(groupParser, extractPhase2SeedKey, {
 		value(state, exec) {
 			return extractPhase2Seed(parser, state, exec);

package/dist/internal/parser.cjs

@@ -8,6 +8,12 @@ const require_input_trace = require('../input-trace.cjs');
 
 //#region src/internal/parser.ts
 /**
+* Internal symbol used by transparent combinators to expose independently
+* competing parse operations to shared-buffer parents.
+* @internal
+*/
+const parseLanesKey = Symbol("parseLanes");
+/**
 * Internal marker for wrappers whose `{ hasCliValue: false }` states should
 * be treated as unmatched dependency-source states during completion-time
 * Phase 1.
@@ -385,6 +391,32 @@ function composeWrappedSourceMetadata(dependencyMetadata, wrapSource) {
 	};
 }
 /**
+* Defines internal parse-lane metadata without exposing it through object
+* spreads used by custom parser wrappers.
+*
+* @internal
+*/
+function defineParseLanes(parser, lanes) {
+	if (lanes == null) return;
+	Object.defineProperty(parser, parseLanesKey, {
+		value: lanes,
+		configurable: true,
+		enumerable: false
+	});
+}
+/**
+* Gets parse-lane metadata defined directly on a parser.
+*
+* Inherited metadata belongs to the parser's prototype and must not bypass an
+* overriding `parse()` implementation on a custom wrapper.
+*
+* @internal
+*/
+function getOwnParseLanes(parser) {
+	if (!Object.hasOwn(parser, parseLanesKey)) return void 0;
+	return parser[parseLanesKey];
+}
+/**
 * Marks a parser as inheriting parent-state annotations through wrapper-state
 * reconstruction.
 *
@@ -712,11 +744,13 @@ exports.annotationWrapperRequiresSourceBindingKey = annotationWrapperRequiresSou
 exports.composeWrappedSourceMetadata = composeWrappedSourceMetadata;
 exports.createParserContext = createParserContext;
 exports.defineInheritedAnnotationParser = defineInheritedAnnotationParser;
+exports.defineParseLanes = defineParseLanes;
 exports.defineSourceBindingOnlyAnnotationCompletionParser = defineSourceBindingOnlyAnnotationCompletionParser;
 exports.getDelegatingSuggestRuntimeNodes = getDelegatingSuggestRuntimeNodes;
 exports.getDocPage = getDocPage;
 exports.getDocPageAsync = getDocPageAsync;
 exports.getDocPageSync = getDocPageSync;
+exports.getOwnParseLanes = getOwnParseLanes;
 exports.getParserSuggestRuntimeNodes = getParserSuggestRuntimeNodes;
 exports.inheritParentAnnotationsKey = inheritParentAnnotationsKey;
 exports.parse = parse;

package/dist/internal/parser.d.cts

@@ -42,6 +42,51 @@ type ModeValue<M extends Mode, T> = M extends "async" ? Promise<T> : T;
  * @since 0.9.0
  */
 type ModeIterable<M extends Mode, T> = M extends "async" ? AsyncIterable<T> : Iterable<T>;
+/**
+ * Internal symbol used by transparent combinators to expose independently
+ * competing parse operations to shared-buffer parents.
+ * @internal
+ */
+declare const parseLanesKey: unique symbol;
+/**
+ * An owner-consumption requirement for a parse lane.
+ * @internal
+ */
+interface ParseLaneConsumptionGroup {
+  /** Identity shared by lanes belonging to the same owning parser. */
+  readonly id: object;
+  /** Whether the owning parser is active after a consuming lane succeeds. */
+  readonly isActive?: (state: unknown) => boolean;
+}
+/**
+ * A state-preserving parse operation that competes at one exact priority.
+ * @internal
+ */
+interface ParseLane<TState> {
+  /** The exact priority at which this lane competes. */
+  readonly priority: number;
+  /**
+   * Identity shared by lanes that must all succeed before their
+   * zero-consumption state updates can be committed.
+   */
+  readonly zeroConsumptionGroup?: object;
+  /**
+   * Whether a zero-consumption success can settle the owning parser while
+   * input remains.  Defaults to `true`.
+   */
+  readonly settlesZeroConsumption?: boolean;
+  /** Fixed tokens reachable through this lane. */
+  readonly leadingNames: ReadonlySet<string>;
+  /** Whether this lane accepts any positional token. */
+  readonly acceptingAnyToken: boolean;
+  /**
+   * Groups in which a zero-consumption update is valid only after another
+   * lane in every group has consumed input during the same arbitration.
+   */
+  readonly requiredConsumptionGroups?: readonly ParseLaneConsumptionGroup[];
+  /** Parses through the owning parser's state and execution context. */
+  parse(context: ParserContext<TState>): ParserResult<TState> | Promise<ParserResult<TState>>;
+}
 /**
  * Combines multiple modes into a single mode.
  * If any mode is `"async"`, the result is `"async"`; otherwise `"sync"`.
@@ -148,6 +193,13 @@ interface Parser<M extends Mode = "sync", TValue = unknown, TState = unknown> {
    * state when parsing starts.
    */
   readonly initialState: TState;
+  /**
+   * Independently competing parse operations exposed by transparent
+   * combinators.  Shared-buffer parents use these to arbitrate below an
+   * aggregate parser boundary without bypassing the owner's state adapters.
+   * @internal
+   */
+  readonly [parseLanesKey]?: readonly ParseLane<TState>[];
   /**
    * Internal marker for wrappers whose `{ hasCliValue: false }` states should
    * be treated as unmatched dependency-source states during completion-time

package/dist/internal/parser.d.ts

@@ -42,6 +42,51 @@ type ModeValue<M extends Mode, T> = M extends "async" ? Promise<T> : T;
  * @since 0.9.0
  */
 type ModeIterable<M extends Mode, T> = M extends "async" ? AsyncIterable<T> : Iterable<T>;
+/**
+ * Internal symbol used by transparent combinators to expose independently
+ * competing parse operations to shared-buffer parents.
+ * @internal
+ */
+declare const parseLanesKey: unique symbol;
+/**
+ * An owner-consumption requirement for a parse lane.
+ * @internal
+ */
+interface ParseLaneConsumptionGroup {
+  /** Identity shared by lanes belonging to the same owning parser. */
+  readonly id: object;
+  /** Whether the owning parser is active after a consuming lane succeeds. */
+  readonly isActive?: (state: unknown) => boolean;
+}
+/**
+ * A state-preserving parse operation that competes at one exact priority.
+ * @internal
+ */
+interface ParseLane<TState> {
+  /** The exact priority at which this lane competes. */
+  readonly priority: number;
+  /**
+   * Identity shared by lanes that must all succeed before their
+   * zero-consumption state updates can be committed.
+   */
+  readonly zeroConsumptionGroup?: object;
+  /**
+   * Whether a zero-consumption success can settle the owning parser while
+   * input remains.  Defaults to `true`.
+   */
+  readonly settlesZeroConsumption?: boolean;
+  /** Fixed tokens reachable through this lane. */
+  readonly leadingNames: ReadonlySet<string>;
+  /** Whether this lane accepts any positional token. */
+  readonly acceptingAnyToken: boolean;
+  /**
+   * Groups in which a zero-consumption update is valid only after another
+   * lane in every group has consumed input during the same arbitration.
+   */
+  readonly requiredConsumptionGroups?: readonly ParseLaneConsumptionGroup[];
+  /** Parses through the owning parser's state and execution context. */
+  parse(context: ParserContext<TState>): ParserResult<TState> | Promise<ParserResult<TState>>;
+}
 /**
  * Combines multiple modes into a single mode.
  * If any mode is `"async"`, the result is `"async"`; otherwise `"sync"`.
@@ -148,6 +193,13 @@ interface Parser<M extends Mode = "sync", TValue = unknown, TState = unknown> {
    * state when parsing starts.
    */
   readonly initialState: TState;
+  /**
+   * Independently competing parse operations exposed by transparent
+   * combinators.  Shared-buffer parents use these to arbitrate below an
+   * aggregate parser boundary without bypassing the owner's state adapters.
+   * @internal
+   */
+  readonly [parseLanesKey]?: readonly ParseLane<TState>[];
   /**
    * Internal marker for wrappers whose `{ hasCliValue: false }` states should
    * be treated as unmatched dependency-source states during completion-time