@optique/core 1.0.0-dev.1616 → 1.0.0-dev.1659

package/dist/constructs.js

@@ -1,13 +1,14 @@
-import { getAnnotations, inheritAnnotations, injectAnnotations } from "./annotations.js";
+import { annotateFreshArray, annotationKey, getAnnotations, inheritAnnotations, injectAnnotations } from "./annotations.js";
 import { message, optionName, text, values } from "./message.js";
-import { DependencyRegistry, createDependencySourceState, dependencyId, isDeferredParseState, isDependencySourceState, isPendingDependencySourceState, isWrappedDependencySource, parseWithDependency, wrappedDependencySourceMarker } from "./dependency.js";
-import { buildRuntimeNodesFromPairs, collectExplicitSourceValues, collectSourcesFromState, createDependencyRuntimeContext, resolveStateWithRuntime, resolveStateWithRuntimeAsync } from "./dependency-runtime.js";
-import { dispatchByMode, dispatchIterableByMode } from "./mode-dispatch.js";
+import { createDependencySourceState, dependencyId, isDependencySourceState, isPendingDependencySourceState, isWrappedDependencySource, wrappedDependencySourceMarker } from "./dependency.js";
 import { validateLabel } from "./validate.js";
 import { extractArgumentMetavars, extractCommandNames, extractOptionNames, isDocHidden, mergeHidden } from "./usage.js";
 import { deduplicateDocFragments } from "./doc.js";
+import { dispatchByMode, dispatchIterableByMode } from "./mode-dispatch.js";
 import { DEFAULT_FIND_SIMILAR_OPTIONS, createErrorWithSuggestions, createSuggestionMessage, deduplicateSuggestions, findSimilar } from "./suggestion.js";
 import { collectLeadingCandidates } from "./usage-internals.js";
+import { defineInheritedAnnotationParser, getParserSuggestRuntimeNodes, inheritParentAnnotationsKey, unmatchedNonCliDependencySourceStateMarker } from "./parser.js";
+import { buildRuntimeNodesFromArray, buildRuntimeNodesFromPairs, collectExplicitSourceValues, collectExplicitSourceValuesAsync, collectSourcesFromState, createDependencyRuntimeContext, fillMissingSourceDefaults, fillMissingSourceDefaultsAsync, resolveStateWithRuntime, resolveStateWithRuntimeAsync } from "./dependency-runtime.js";
 
 //#region src/constructs.ts
 /**
@@ -15,6 +16,67 @@ import { collectLeadingCandidates } from "./usage-internals.js";
 * do not match any specific name at the first buffer position.
 */
 const EMPTY_LEADING_NAMES = /* @__PURE__ */ new Set();
+function isNonCliBoundSourceState(state, parser) {
+	return parser[unmatchedNonCliDependencySourceStateMarker] === true && state != null && typeof state === "object" && Object.hasOwn(state, "hasCliValue") && state.hasCliValue === false;
+}
+function withChildExecPath(exec, segment) {
+	if (exec == null) return void 0;
+	return {
+		...exec,
+		path: [...exec.path ?? [], segment]
+	};
+}
+function mergeChildExec(parent, child) {
+	if (parent == null) return child;
+	if (child == null) return parent;
+	return {
+		...parent,
+		trace: child.trace ?? parent.trace,
+		dependencyRuntime: child.dependencyRuntime ?? parent.dependencyRuntime,
+		dependencyRegistry: child.dependencyRegistry ?? parent.dependencyRegistry,
+		preCompletedByParser: child.preCompletedByParser ?? parent.preCompletedByParser,
+		excludedSourceFields: child.excludedSourceFields ?? parent.excludedSourceFields
+	};
+}
+function withChildContext(context, segment, state, parser, usage) {
+	const exec = withChildExecPath(context.exec, segment);
+	const dependencyRegistry = context.dependencyRegistry ?? exec?.dependencyRegistry;
+	const childState = parser == null ? state : getParseChildState(context.state, state, parser);
+	return {
+		...context,
+		state: childState,
+		...usage != null ? { usage } : {},
+		...exec != null ? {
+			exec: dependencyRegistry === exec.dependencyRegistry ? exec : {
+				...exec,
+				dependencyRegistry
+			},
+			dependencyRegistry
+		} : {}
+	};
+}
+function isUnmatchedDependencyState(state, parser) {
+	if (state === void 0) return true;
+	if (Array.isArray(state) && state.length === 1 && isPendingDependencySourceState(state[0])) return true;
+	if (isPendingDependencySourceState(state)) return true;
+	if (isNonCliBoundSourceState(state, parser)) return true;
+	return state === parser.initialState;
+}
+function filterPreCompletedRuntimeNodes(nodes, preCompletedKeys) {
+	if (preCompletedKeys.size < 1) return nodes;
+	return nodes.filter((node) => {
+		const segment = node.path.at(-1);
+		if (typeof segment === "number") return !preCompletedKeys.has(String(segment));
+		return segment == null || !preCompletedKeys.has(segment);
+	});
+}
+function buildIndexedParserPairs(parsers) {
+	return parsers.map((parser, index) => [String(index), parser]);
+}
+function createAnnotatedArrayStateRecord(stateArray) {
+	const stateRecord = Object.fromEntries(stateArray.map((state, index) => [String(index), state]));
+	return inheritAnnotations(stateArray, stateRecord);
+}
 /**
 * Computes the union of `leadingNames` from all given parsers.
 * Used for alternative combinators (`or()`, `longestMatch()`) where all
@@ -47,7 +109,6 @@ function sharedBufferLeadingNames(parsers) {
 	}
 	return names.size === 0 ? EMPTY_LEADING_NAMES : names;
 }
-const inheritParentAnnotationsKey = Symbol.for("@optique/core/inheritParentAnnotations");
 /**
 * Internal symbol for exposing field-level parser pairs from `object()`
 * and `merge()` parsers.  This allows `merge()` to pre-complete dependency
@@ -62,9 +123,73 @@ const fieldParsersKey = Symbol("fieldParsers");
 * to consume results from parsers that still return `DependencySourceState`.
 * @internal
 */
+function unwrapAnnotationView(value) {
+	if (value == null || typeof value !== "object") return value;
+	return annotationViewTargets.get(value) ?? value;
+}
+function containsAnnotationView(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value == null || typeof value !== "object") return false;
+	const candidate = value;
+	if (annotationViewTargets.has(candidate)) return true;
+	const source = unwrapAnnotationView(candidate);
+	if (seen.has(source)) return false;
+	seen.add(source);
+	if (Array.isArray(source)) return source.some((item) => containsAnnotationView(item, seen));
+	const proto = Object.getPrototypeOf(source);
+	if (proto !== Object.prototype && proto !== null) return false;
+	return Reflect.ownKeys(source).some((key) => containsAnnotationView(source[key], seen));
+}
+function unwrapNestedAnnotationViews(value, seen = /* @__PURE__ */ new WeakMap()) {
+	if (value == null || typeof value !== "object") return value;
+	const source = unwrapAnnotationView(value);
+	if (seen.has(source)) return seen.get(source);
+	if (Array.isArray(source)) {
+		let changed$1 = false;
+		const clone$1 = [...source];
+		seen.set(source, clone$1);
+		for (let i = 0; i < source.length; i++) {
+			const nextValue = unwrapNestedAnnotationViews(source[i], seen);
+			if (nextValue !== source[i]) {
+				clone$1[i] = nextValue;
+				changed$1 = true;
+			}
+		}
+		return changed$1 ? clone$1 : source;
+	}
+	const proto = Object.getPrototypeOf(source);
+	if (proto !== Object.prototype && proto !== null) return source;
+	const descriptors = Object.getOwnPropertyDescriptors(source);
+	let changed = false;
+	const clone = Object.create(proto);
+	seen.set(source, clone);
+	for (const key of Reflect.ownKeys(descriptors)) {
+		const descriptor = descriptors[key];
+		if (descriptor != null && "value" in descriptor) {
+			const nextValue = unwrapNestedAnnotationViews(descriptor.value, seen);
+			if (nextValue !== descriptor.value) {
+				descriptors[key] = {
+					...descriptor,
+					value: nextValue
+				};
+				changed = true;
+			}
+		}
+	}
+	if (!changed) {
+		seen.set(source, source);
+		return source;
+	}
+	Object.defineProperties(clone, descriptors);
+	return clone;
+}
 function unwrapCompleteResult(result) {
-	if (isDependencySourceState(result)) return result.result;
-	return result;
+	const unwrappedResult = isDependencySourceState(result) ? result.result : result;
+	if (!unwrappedResult.success || !containsAnnotationView(unwrappedResult.value)) return unwrappedResult;
+	const value = unwrapNestedAnnotationViews(unwrappedResult.value);
+	return value === unwrappedResult.value ? unwrappedResult : {
+		...unwrappedResult,
+		value
+	};
 }
 /**
 * Prepares a field state for completion by wrapping `undefined` state
@@ -85,18 +210,80 @@ function prepareStateForCompletion(fieldState, parser) {
 }
 /**
 * Returns the field state with parent annotations inherited, respecting
-* the parser's {@link inheritParentAnnotationsKey} flag.  This is the
-* same logic as {@link createFieldStateGetter} inside `object()` but
-* without the per-state cache, for use in module-level helpers like
+* the parser's annotation-inheritance contract. This is the same logic as
+* {@link createFieldStateGetter} inside `object()` but without the per-state
+* cache, for use in module-level helpers like
 * {@link pendingDependencyDefaults}.
 * @internal
 */
 function getAnnotatedFieldState(parentState, field, parser) {
 	const sourceState = parentState != null && typeof parentState === "object" && field in parentState ? parentState[field] : parser.initialState;
-	if (sourceState == null || typeof sourceState !== "object") return sourceState;
+	return getAnnotatedChildState(parentState, sourceState, parser);
+}
+const annotationViewTargets = /* @__PURE__ */ new WeakMap();
+function withAnnotationView(state, annotations) {
+	const view = new Proxy(state, {
+		get(target, key) {
+			if (key === annotationKey) return annotations;
+			const value = Reflect.get(target, key, target);
+			return typeof value === "function" ? value.bind(target) : value;
+		},
+		has(target, key) {
+			return key === annotationKey || Reflect.has(target, key);
+		}
+	});
+	annotationViewTargets.set(view, state);
+	return view;
+}
+function getParseChildState(parentState, childState, parser) {
+	const annotations = getAnnotations(parentState);
+	const shouldInheritAnnotations = Reflect.get(parser, inheritParentAnnotationsKey) === true;
+	if (childState == null) {
+		if (annotations !== void 0 && shouldInheritAnnotations) return injectAnnotations({}, annotations);
+		return childState;
+	}
+	if (annotations === void 0 || typeof childState !== "object" || getAnnotations(childState) === annotations || !shouldInheritAnnotations) return childState;
+	const injectedState = injectAnnotations(childState, annotations);
+	return getAnnotations(injectedState) === annotations ? injectedState : childState;
+}
+function getObjectParseChildState(parentState, childState, _parser) {
 	const annotations = getAnnotations(parentState);
-	if (annotations === void 0 || getAnnotations(sourceState) === annotations) return sourceState;
-	return Reflect.get(parser, inheritParentAnnotationsKey) === true ? injectAnnotations(sourceState, annotations) : inheritAnnotations(parentState, sourceState);
+	if (annotations === void 0 || childState == null || typeof childState !== "object" || getAnnotations(childState) === annotations) return childState;
+	return injectAnnotations(childState, annotations);
+}
+function getAnnotatedChildState(parentState, childState, parser) {
+	const annotations = getAnnotations(parentState);
+	const shouldInheritAnnotations = Reflect.get(parser, inheritParentAnnotationsKey) === true;
+	if (childState == null) {
+		if (annotations !== void 0 && shouldInheritAnnotations) return injectAnnotations({}, annotations);
+		return childState;
+	}
+	if (typeof childState !== "object") return childState;
+	if (annotations === void 0 || getAnnotations(childState) === annotations) return childState;
+	if (shouldInheritAnnotations) {
+		const injectedState = injectAnnotations(childState, annotations);
+		if (getAnnotations(injectedState) === annotations) return injectedState;
+	}
+	return withAnnotationView(childState, annotations);
+}
+function buildSuggestRuntimeNodesFromPairs(pairs, state, parentPath) {
+	const prefix = parentPath ?? [];
+	const nodes = [];
+	for (const [field, parser] of pairs) {
+		const fieldState = Object.hasOwn(state, field) ? state[field] : parser.initialState;
+		nodes.push(...getParserSuggestRuntimeNodes(parser, getAnnotatedChildState(state, fieldState, parser), [...prefix, field]));
+	}
+	return nodes;
+}
+function buildSuggestRuntimeNodesFromArray(parsers, stateArray, parentPath) {
+	const prefix = parentPath ?? [];
+	const nodes = [];
+	for (let i = 0; i < parsers.length; i++) {
+		const parser = parsers[i];
+		const elementState = i < stateArray.length ? stateArray[i] : void 0;
+		nodes.push(...getParserSuggestRuntimeNodes(parser, getAnnotatedChildState(stateArray, elementState, parser), [...prefix, i]));
+	}
+	return nodes;
 }
 function createUnexpectedInputErrorWithScopedSuggestions(baseError, invalidInput, parsers, customFormatter) {
 	const options = /* @__PURE__ */ new Set();
@@ -304,8 +491,8 @@ function createExclusiveComplete(parsers, options, noMatchContext, mode) {
 			success: false,
 			error: result.error
 		};
-		return dispatchByMode(mode, () => syncParsers[i].complete(result.next.state, exec), async () => {
-			const completeResult = await parsers[i].complete(result.next.state, exec);
+		return dispatchByMode(mode, () => syncParsers[i].complete(result.next.state, withChildExecPath(exec, i)), async () => {
+			const completeResult = await parsers[i].complete(result.next.state, withChildExecPath(exec, i));
 			return completeResult;
 		});
 	};
@@ -319,31 +506,24 @@ function createExclusiveSuggest(parsers, mode) {
 	return (context, prefix) => {
 		return dispatchIterableByMode(mode, function* () {
 			const suggestions = [];
-			if (context.state == null) for (const parser of syncParsers) {
-				const parserSuggestions = parser.suggest({
-					...context,
-					state: parser.initialState
-				}, prefix);
+			if (context.state == null) for (let i = 0; i < syncParsers.length; i++) {
+				const parser = syncParsers[i];
+				const parserSuggestions = parser.suggest(withChildContext(context, i, parser.initialState), prefix);
 				suggestions.push(...parserSuggestions);
 			}
 			else {
 				const [index, parserResult] = context.state;
 				if (parserResult.success) {
-					const parserSuggestions = syncParsers[index].suggest({
-						...context,
-						state: parserResult.next.state
-					}, prefix);
+					const parserSuggestions = syncParsers[index].suggest(withChildContext(context, index, parserResult.next.state), prefix);
 					suggestions.push(...parserSuggestions);
 				}
 			}
 			yield* deduplicateSuggestions(suggestions);
 		}, async function* () {
 			const suggestions = [];
-			if (context.state == null) for (const parser of parsers) {
-				const parserSuggestions = parser.suggest({
-					...context,
-					state: parser.initialState
-				}, prefix);
+			if (context.state == null) for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const parserSuggestions = parser.suggest(withChildContext(context, i, parser.initialState), prefix);
 				if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
 				else suggestions.push(...parserSuggestions);
 			}
@@ -351,10 +531,7 @@ function createExclusiveSuggest(parsers, mode) {
 				const [index, parserResult] = context.state;
 				if (parserResult.success) {
 					const parser = parsers[index];
-					const parserSuggestions = parser.suggest({
-						...context,
-						state: parserResult.next.state
-					}, prefix);
+					const parserSuggestions = parser.suggest(withChildContext(context, index, parserResult.next.state), prefix);
 					if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
 					else suggestions.push(...parserSuggestions);
 				}
@@ -363,6 +540,13 @@ function createExclusiveSuggest(parsers, mode) {
 		});
 	};
 }
+function getExclusiveSuggestRuntimeNodes(parsers, state, path) {
+	if (!Array.isArray(state) || state.length !== 2 || typeof state[0] !== "number") return [];
+	const [index, parserResult] = state;
+	if (!parserResult?.success || index < 0 || index >= parsers.length) return [];
+	const parser = parsers[index];
+	return getParserSuggestRuntimeNodes(parser, parserResult.next.state, [...path, index]);
+}
 /**
 * Gets the no-match error, either from custom options or default.
 * Shared by or() and longestMatch().
@@ -372,6 +556,26 @@ function getNoMatchError(options, noMatchContext) {
 	const customNoMatch = options?.errors?.noMatch;
 	return customNoMatch ? typeof customNoMatch === "function" ? customNoMatch(noMatchContext) : customNoMatch : generateNoMatchError(noMatchContext);
 }
+function composeExclusiveDependencyMetadata(parsers) {
+	const sourceBranches = parsers.filter((parser) => parser.dependencyMetadata?.source != null);
+	if (sourceBranches.length < 1) return void 0;
+	const sourceIds = new Set(sourceBranches.map((parser) => parser.dependencyMetadata.source.sourceId));
+	if (sourceIds.size !== 1) return void 0;
+	const sharedSource = sourceBranches[0].dependencyMetadata.source;
+	return { source: {
+		...sharedSource,
+		getMissingSourceValue: void 0,
+		preservesSourceValue: sourceBranches.every((parser) => parser.dependencyMetadata?.source?.preservesSourceValue !== false),
+		extractSourceValue(state) {
+			if (!Array.isArray(state) || state.length !== 2 || typeof state[0] !== "number") return void 0;
+			const [index, parserResult] = state;
+			if (!parserResult?.success) return void 0;
+			const branchSource = parsers[index].dependencyMetadata?.source;
+			if (branchSource?.extractSourceValue == null) return void 0;
+			return branchSource.extractSourceValue(parserResult.next.state);
+		}
+	} };
+}
 /**
 * @since 0.5.0
 */
@@ -404,17 +608,13 @@ function or(...args) {
 		const orderedParsers = syncParsers.map((p, i) => [p, i]);
 		orderedParsers.sort(([_, a], [__, b]) => context.state?.[0] === a ? -1 : context.state?.[0] === b ? 1 : a - b);
 		for (const [parser, i] of orderedParsers) {
-			const result = parser.parse({
-				...context,
-				state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
-			});
+			const result = parser.parse(withChildContext(context, i, context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state));
 			if (result.success && result.consumed.length > 0) {
 				if (context.state?.[0] !== i && context.state?.[1].success) {
 					const previouslyConsumed = context.state[1].consumed;
 					const checkResult = parser.parse({
-						...context,
-						buffer: previouslyConsumed,
-						state: parser.initialState
+						...withChildContext(context, i, parser.initialState),
+						buffer: previouslyConsumed
 					});
 					const canConsumeShared = checkResult.success && checkResult.consumed.length === previouslyConsumed.length && checkResult.consumed.every((c, idx) => c === previouslyConsumed[idx]);
 					if (!canConsumeShared) return {
@@ -422,11 +622,19 @@ function or(...args) {
 						consumed: context.buffer.length - result.next.buffer.length,
 						error: message`${values(context.state[1].consumed)} and ${values(result.consumed)} cannot be used together.`
 					};
+					const replayExec = mergeChildExec(context.exec, checkResult.next.exec);
 					const replayedResult = parser.parse({
-						...context,
+						...withChildContext({
+							...context,
+							...replayExec != null ? {
+								exec: replayExec,
+								dependencyRegistry: replayExec.dependencyRegistry
+							} : {}
+						}, i, checkResult.next.state),
 						state: checkResult.next.state
 					});
 					if (!replayedResult.success) return replayedResult;
+					const mergedExec$1 = mergeChildExec(replayExec, replayedResult.next.exec);
 					return {
 						success: true,
 						next: {
@@ -436,18 +644,27 @@ function or(...args) {
 							state: [i, {
 								...replayedResult,
 								consumed: [...previouslyConsumed, ...replayedResult.consumed]
-							}]
+							}],
+							...mergedExec$1 != null ? {
+								exec: mergedExec$1,
+								dependencyRegistry: mergedExec$1.dependencyRegistry
+							} : {}
 						},
 						consumed: replayedResult.consumed
 					};
 				}
+				const mergedExec = mergeChildExec(context.exec, result.next.exec);
 				return {
 					success: true,
 					next: {
 						...context,
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
-						state: [i, result]
+						state: [i, result],
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					},
 					consumed: result.consumed
 				};
@@ -463,18 +680,14 @@ function or(...args) {
 		const orderedParsers = parsers.map((p, i) => [p, i]);
 		orderedParsers.sort(([_, a], [__, b]) => context.state?.[0] === a ? -1 : context.state?.[0] === b ? 1 : a - b);
 		for (const [parser, i] of orderedParsers) {
-			const resultOrPromise = parser.parse({
-				...context,
-				state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
-			});
+			const resultOrPromise = parser.parse(withChildContext(context, i, context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state));
 			const result = await resultOrPromise;
 			if (result.success && result.consumed.length > 0) {
 				if (context.state?.[0] !== i && context.state?.[1].success) {
 					const previouslyConsumed = context.state[1].consumed;
 					const checkResultOrPromise = parser.parse({
-						...context,
-						buffer: previouslyConsumed,
-						state: parser.initialState
+						...withChildContext(context, i, parser.initialState),
+						buffer: previouslyConsumed
 					});
 					const checkResult = await checkResultOrPromise;
 					const canConsumeShared = checkResult.success && checkResult.consumed.length === previouslyConsumed.length && checkResult.consumed.every((c, idx) => c === previouslyConsumed[idx]);
@@ -483,12 +696,17 @@ function or(...args) {
 						consumed: context.buffer.length - result.next.buffer.length,
 						error: message`${values(context.state[1].consumed)} and ${values(result.consumed)} cannot be used together.`
 					};
-					const replayedResultOrPromise = parser.parse({
+					const replayExec = mergeChildExec(context.exec, checkResult.next.exec);
+					const replayedResultOrPromise = parser.parse({ ...withChildContext({
 						...context,
-						state: checkResult.next.state
-					});
+						...replayExec != null ? {
+							exec: replayExec,
+							dependencyRegistry: replayExec.dependencyRegistry
+						} : {}
+					}, i, checkResult.next.state) });
 					const replayedResult = await replayedResultOrPromise;
 					if (!replayedResult.success) return replayedResult;
+					const mergedExec$1 = mergeChildExec(replayExec, replayedResult.next.exec);
 					return {
 						success: true,
 						next: {
@@ -498,18 +716,27 @@ function or(...args) {
 							state: [i, {
 								...replayedResult,
 								consumed: [...previouslyConsumed, ...replayedResult.consumed]
-							}]
+							}],
+							...mergedExec$1 != null ? {
+								exec: mergedExec$1,
+								dependencyRegistry: mergedExec$1.dependencyRegistry
+							} : {}
 						},
 						consumed: replayedResult.consumed
 					};
 				}
+				const mergedExec = mergeChildExec(context.exec, result.next.exec);
 				return {
 					success: true,
 					next: {
 						...context,
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
-						state: [i, result]
+						state: [i, result],
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					},
 					consumed: result.consumed
 				};
@@ -536,6 +763,9 @@ function or(...args) {
 		parse(context) {
 			return dispatchByMode(combinedMode, () => parseSync(context), () => parseAsync(context));
 		},
+		getSuggestRuntimeNodes(state, path) {
+			return getExclusiveSuggestRuntimeNodes(parsers, state, path);
+		},
 		suggest: createExclusiveSuggest(parsers, combinedMode),
 		getDocFragments(state, _defaultValue) {
 			let brief;
@@ -564,6 +794,8 @@ function or(...args) {
 			};
 		}
 	};
+	const singleDependencyMetadata = composeExclusiveDependencyMetadata(parsers);
+	if (singleDependencyMetadata != null) singleResult.dependencyMetadata = singleDependencyMetadata;
 	return singleResult;
 }
 /**
@@ -598,10 +830,7 @@ function longestMatch(...args) {
 		let error = getInitialError(context);
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
-			const result = parser.parse({
-				...context,
-				state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
-			});
+			const result = parser.parse(withChildContext(context, i, context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state));
 			if (result.success) {
 				const consumed = context.buffer.length - result.next.buffer.length;
 				if (bestMatch === null || consumed > bestMatch.consumed) bestMatch = {
@@ -611,16 +840,23 @@ function longestMatch(...args) {
 				};
 			} else if (error.consumed < result.consumed) error = result;
 		}
-		if (bestMatch && bestMatch.result.success) return {
-			success: true,
-			next: {
-				...context,
-				buffer: bestMatch.result.next.buffer,
-				optionsTerminated: bestMatch.result.next.optionsTerminated,
-				state: [bestMatch.index, bestMatch.result]
-			},
-			consumed: bestMatch.result.consumed
-		};
+		if (bestMatch && bestMatch.result.success) {
+			const mergedExec = mergeChildExec(context.exec, bestMatch.result.next.exec);
+			return {
+				success: true,
+				next: {
+					...context,
+					buffer: bestMatch.result.next.buffer,
+					optionsTerminated: bestMatch.result.next.optionsTerminated,
+					state: [bestMatch.index, bestMatch.result],
+					...mergedExec != null ? {
+						exec: mergedExec,
+						dependencyRegistry: mergedExec.dependencyRegistry
+					} : {}
+				},
+				consumed: bestMatch.result.consumed
+			};
+		}
 		return {
 			...error,
 			success: false
@@ -631,10 +867,7 @@ function longestMatch(...args) {
 		let error = getInitialError(context);
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
-			const resultOrPromise = parser.parse({
-				...context,
-				state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
-			});
+			const resultOrPromise = parser.parse(withChildContext(context, i, context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state));
 			const result = await resultOrPromise;
 			if (result.success) {
 				const consumed = context.buffer.length - result.next.buffer.length;
@@ -645,16 +878,23 @@ function longestMatch(...args) {
 				};
 			} else if (error.consumed < result.consumed) error = result;
 		}
-		if (bestMatch && bestMatch.result.success) return {
-			success: true,
-			next: {
-				...context,
-				buffer: bestMatch.result.next.buffer,
-				optionsTerminated: bestMatch.result.next.optionsTerminated,
-				state: [bestMatch.index, bestMatch.result]
-			},
-			consumed: bestMatch.result.consumed
-		};
+		if (bestMatch && bestMatch.result.success) {
+			const mergedExec = mergeChildExec(context.exec, bestMatch.result.next.exec);
+			return {
+				success: true,
+				next: {
+					...context,
+					buffer: bestMatch.result.next.buffer,
+					optionsTerminated: bestMatch.result.next.optionsTerminated,
+					state: [bestMatch.index, bestMatch.result],
+					...mergedExec != null ? {
+						exec: mergedExec,
+						dependencyRegistry: mergedExec.dependencyRegistry
+					} : {}
+				},
+				consumed: bestMatch.result.consumed
+			};
+		}
 		return {
 			...error,
 			success: false
@@ -676,6 +916,9 @@ function longestMatch(...args) {
 		parse(context) {
 			return dispatchByMode(combinedMode, () => parseSync(context), () => parseAsync(context));
 		},
+		getSuggestRuntimeNodes(state, path) {
+			return getExclusiveSuggestRuntimeNodes(parsers, state, path);
+		},
 		suggest: createExclusiveSuggest(parsers, combinedMode),
 		getDocFragments(state, _defaultValue) {
 			let brief;
@@ -711,6 +954,8 @@ function longestMatch(...args) {
 			};
 		}
 	};
+	const multiDependencyMetadata = composeExclusiveDependencyMetadata(parsers);
+	if (multiDependencyMetadata != null) multiResult.dependencyMetadata = multiDependencyMetadata;
 	return multiResult;
 }
 /**
@@ -719,32 +964,32 @@ function longestMatch(...args) {
 */
 function* suggestObjectSync(context, prefix, parserPairs) {
 	const runtime = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
-	const nodes = buildRuntimeNodesFromPairs(parserPairs, context.state && typeof context.state === "object" ? context.state : {}, context.exec?.path);
+	const sourceParserPairs = filterExcludedFieldParsers(parserPairs, context.exec?.excludedSourceFields);
+	const nodes = buildRuntimeNodesFromPairs(sourceParserPairs, context.state && typeof context.state === "object" ? context.state : {}, context.exec?.path);
 	collectExplicitSourceValues(nodes, runtime);
-	if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime);
-	completeDependencySourceDefaults(context, parserPairs, runtime.registry, context.exec);
+	if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime, /* @__PURE__ */ new WeakSet(), context.exec?.excludedSourceFields);
+	completeDependencySourceDefaults(context, sourceParserPairs, runtime.registry, context.exec);
 	const contextWithRegistry = {
 		...context,
-		dependencyRegistry: runtime.registry
+		dependencyRegistry: runtime.registry,
+		...context.exec != null ? { exec: {
+			...context.exec,
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		} } : {}
 	};
 	if (context.buffer.length > 0) {
 		const lastToken = context.buffer[context.buffer.length - 1];
 		for (const [field, parser] of parserPairs) if (isOptionRequiringValue(parser.usage, lastToken)) {
 			const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-			yield* parser.suggest({
-				...contextWithRegistry,
-				state: fieldState
-			}, prefix);
+			yield* parser.suggest(withChildContext(contextWithRegistry, field, fieldState), prefix);
 			return;
 		}
 	}
 	const suggestions = [];
 	for (const [field, parser] of parserPairs) {
 		const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-		const fieldSuggestions = parser.suggest({
-			...contextWithRegistry,
-			state: fieldState
-		}, prefix);
+		const fieldSuggestions = parser.suggest(withChildContext(contextWithRegistry, field, fieldState), prefix);
 		suggestions.push(...fieldSuggestions);
 	}
 	yield* deduplicateSuggestions(suggestions);
@@ -755,22 +1000,25 @@ function* suggestObjectSync(context, prefix, parserPairs) {
 */
 async function* suggestObjectAsync(context, prefix, parserPairs) {
 	const runtime = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
-	const nodes = buildRuntimeNodesFromPairs(parserPairs, context.state && typeof context.state === "object" ? context.state : {}, context.exec?.path);
-	collectExplicitSourceValues(nodes, runtime);
-	if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime);
-	await completeDependencySourceDefaultsAsync(context, parserPairs, runtime.registry, context.exec);
+	const sourceParserPairs = filterExcludedFieldParsers(parserPairs, context.exec?.excludedSourceFields);
+	const nodes = buildRuntimeNodesFromPairs(sourceParserPairs, context.state && typeof context.state === "object" ? context.state : {}, context.exec?.path);
+	await collectExplicitSourceValuesAsync(nodes, runtime);
+	if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime, /* @__PURE__ */ new WeakSet(), context.exec?.excludedSourceFields);
+	await completeDependencySourceDefaultsAsync(context, sourceParserPairs, runtime.registry, context.exec);
 	const contextWithRegistry = {
 		...context,
-		dependencyRegistry: runtime.registry
+		dependencyRegistry: runtime.registry,
+		...context.exec != null ? { exec: {
+			...context.exec,
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		} } : {}
 	};
 	if (context.buffer.length > 0) {
 		const lastToken = context.buffer[context.buffer.length - 1];
 		for (const [field, parser] of parserPairs) if (isOptionRequiringValue(parser.usage, lastToken)) {
 			const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-			const suggestions$1 = parser.suggest({
-				...contextWithRegistry,
-				state: fieldState
-			}, prefix);
+			const suggestions$1 = parser.suggest(withChildContext(contextWithRegistry, field, fieldState), prefix);
 			for await (const s of suggestions$1) yield s;
 			return;
 		}
@@ -778,10 +1026,7 @@ async function* suggestObjectAsync(context, prefix, parserPairs) {
 	const suggestions = [];
 	for (const [field, parser] of parserPairs) {
 		const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-		const fieldSuggestions = parser.suggest({
-			...contextWithRegistry,
-			state: fieldState
-		}, prefix);
+		const fieldSuggestions = parser.suggest(withChildContext(contextWithRegistry, field, fieldState), prefix);
 		for await (const s of fieldSuggestions) suggestions.push(s);
 	}
 	yield* deduplicateSuggestions(suggestions);
@@ -802,9 +1047,26 @@ function registerCompletedDependency(completed, registry) {
 * @see https://github.com/dahlia/optique/issues/186
 * @internal
 */
-function* pendingDependencyDefaults(context, parserPairs) {
+function* pendingDependencyDefaults(context, parserPairs, registry) {
 	for (const [field, fieldParser] of parserPairs) {
+		const sourceId = fieldParser.dependencyMetadata?.source?.sourceId ?? (isWrappedDependencySource(fieldParser) ? fieldParser[wrappedDependencySourceMarker][dependencyId] : isPendingDependencySourceState(fieldParser.initialState) ? fieldParser.initialState[dependencyId] : void 0);
+		if (sourceId != null && registry?.has(sourceId)) continue;
 		const fieldState = context.state != null && typeof context.state === "object" && field in context.state ? context.state[field] : void 0;
+		const annotatedFieldState = getAnnotatedFieldState(context.state, field, fieldParser);
+		if (fieldParser.dependencyMetadata?.source?.getMissingSourceValue != null && isUnmatchedDependencyState(fieldState, fieldParser)) {
+			yield {
+				parser: fieldParser,
+				state: annotatedFieldState
+			};
+			continue;
+		}
+		if (fieldParser.dependencyMetadata?.source != null && isUnmatchedDependencyState(fieldState, fieldParser) && (annotatedFieldState !== fieldState || isNonCliBoundSourceState(fieldState, fieldParser))) {
+			yield {
+				parser: fieldParser,
+				state: annotatedFieldState
+			};
+			continue;
+		}
 		if (fieldState != null) {
 			if (!Array.isArray(fieldState) && !isDependencySourceState(fieldState) && (isWrappedDependencySource(fieldParser) || isPendingDependencySourceState(fieldParser.initialState))) yield {
 				parser: fieldParser,
@@ -832,7 +1094,7 @@ function* pendingDependencyDefaults(context, parserPairs) {
 * @internal
 */
 function completeDependencySourceDefaults(context, parserPairs, registry, exec) {
-	for (const { parser, state } of pendingDependencyDefaults(context, parserPairs)) {
+	for (const { parser, state } of pendingDependencyDefaults(context, parserPairs, registry)) {
 		const completed = parser.complete(state, exec);
 		const depState = wrapAsDependencySourceState(completed, parser);
 		if (depState) registerCompletedDependency(depState, registry);
@@ -851,9 +1113,11 @@ function completeDependencySourceDefaults(context, parserPairs, registry, exec)
 */
 function wrapAsDependencySourceState(completed, parser) {
 	if (isDependencySourceState(completed)) return completed;
-	const hasDep = isWrappedDependencySource(parser) || isPendingDependencySourceState(parser.initialState);
+	const metadataSource = parser.dependencyMetadata?.source;
+	if (metadataSource?.preservesSourceValue === false) return void 0;
+	const hasDep = metadataSource != null || isWrappedDependencySource(parser) || isPendingDependencySourceState(parser.initialState);
 	if (hasDep && typeof completed === "object" && completed !== null && "success" in completed && completed.success && "value" in completed && completed.value !== void 0) {
-		const depId = isWrappedDependencySource(parser) ? parser[wrappedDependencySourceMarker][dependencyId] : parser.initialState[dependencyId];
+		const depId = metadataSource?.sourceId ?? (isWrappedDependencySource(parser) ? parser[wrappedDependencySourceMarker][dependencyId] : parser.initialState[dependencyId]);
 		return createDependencySourceState(completed, depId);
 	}
 	return void 0;
@@ -867,7 +1131,7 @@ function wrapAsDependencySourceState(completed, parser) {
 * @internal
 */
 async function completeDependencySourceDefaultsAsync(context, parserPairs, registry, exec) {
-	for (const { parser, state } of pendingDependencyDefaults(context, parserPairs)) {
+	for (const { parser, state } of pendingDependencyDefaults(context, parserPairs, registry)) {
 		const completed = await parser.complete(state, exec);
 		const depState = wrapAsDependencySourceState(completed, parser);
 		if (depState) registerCompletedDependency(depState, registry);
@@ -909,6 +1173,20 @@ function collectChildFieldParsers(parsers) {
 	for (const parser of parsers) if (fieldParsersKey in parser) pairs.push(...parser[fieldParsersKey]);
 	return pairs;
 }
+function filterDuplicateFieldParsers(pairs) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const [field] of pairs) counts.set(field, (counts.get(field) ?? 0) + 1);
+	return pairs.filter(([field]) => (counts.get(field) ?? 0) <= 1);
+}
+function collectDuplicateFieldNames(pairs) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const [field] of pairs) counts.set(field, (counts.get(field) ?? 0) + 1);
+	return new Set([...counts.entries()].filter(([, count]) => count > 1).map(([field]) => field));
+}
+function filterExcludedFieldParsers(pairs, excludedFields) {
+	if (excludedFields == null || excludedFields.size < 1) return pairs;
+	return pairs.filter(([field]) => !excludedFields.has(field));
+}
 /**
 * Pre-completes dependency source fields and registers their values in
 * the given registry.  Unlike `completeDependencySourceDefaults()` (used
@@ -935,22 +1213,37 @@ function preCompleteAndRegisterDependencies(state, fieldParserPairs, registry, e
 			continue;
 		}
 		const fieldState = state[field];
+		const annotatedFieldState = getAnnotatedFieldState(state, field, fieldParser);
+		if (fieldParser.dependencyMetadata?.source?.getMissingSourceValue != null && isUnmatchedDependencyState(fieldState, fieldParser)) {
+			const completed = fieldParser.complete(annotatedFieldState, withChildExecPath(exec, field));
+			preCompleted.set(field, completed);
+			const depState = wrapAsDependencySourceState(completed, fieldParser);
+			if (depState) registerCompletedDependency(depState, registry);
+			continue;
+		}
+		if (fieldParser.dependencyMetadata?.source != null && isUnmatchedDependencyState(fieldState, fieldParser) && (annotatedFieldState !== fieldState || isNonCliBoundSourceState(fieldState, fieldParser))) {
+			const completed = fieldParser.complete(annotatedFieldState, withChildExecPath(exec, field));
+			preCompleted.set(field, completed);
+			const depState = wrapAsDependencySourceState(completed, fieldParser);
+			if (depState) registerCompletedDependency(depState, registry);
+			continue;
+		}
 		if (Array.isArray(fieldState) && fieldState.length === 1 && isPendingDependencySourceState(fieldState[0])) {
-			const completed = fieldParser.complete(fieldState, exec);
+			const completed = fieldParser.complete(fieldState, withChildExecPath(exec, field));
 			preCompleted.set(field, completed);
 			if (isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
 		} else if (fieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState)) {
-			const completed = fieldParser.complete([fieldParser.initialState], exec);
+			const completed = fieldParser.complete([fieldParser.initialState], withChildExecPath(exec, field));
 			preCompleted.set(field, completed);
 			if (isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
 		} else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
 			const pendingState = fieldParser[wrappedDependencySourceMarker];
-			const completed = fieldParser.complete([pendingState], exec);
+			const completed = fieldParser.complete([pendingState], withChildExecPath(exec, field));
 			preCompleted.set(field, completed);
 			if (isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
 		} else if (fieldState != null && !Array.isArray(fieldState) && !isDependencySourceState(fieldState) && (isWrappedDependencySource(fieldParser) || isPendingDependencySourceState(fieldParser.initialState))) {
-			const annotatedFieldState = getAnnotatedFieldState(state, field, fieldParser);
-			const completed = fieldParser.complete(annotatedFieldState, exec);
+			const annotatedFieldState$1 = getAnnotatedFieldState(state, field, fieldParser);
+			const completed = fieldParser.complete(annotatedFieldState$1, withChildExecPath(exec, field));
 			preCompleted.set(field, completed);
 			const depState = wrapAsDependencySourceState(completed, fieldParser);
 			if (depState) registerCompletedDependency(depState, registry);
@@ -973,22 +1266,37 @@ async function preCompleteAndRegisterDependenciesAsync(state, fieldParserPairs,
 			continue;
 		}
 		const fieldState = state[field];
+		const annotatedFieldState = getAnnotatedFieldState(state, field, fieldParser);
+		if (fieldParser.dependencyMetadata?.source?.getMissingSourceValue != null && isUnmatchedDependencyState(fieldState, fieldParser)) {
+			const completed = await fieldParser.complete(annotatedFieldState, withChildExecPath(exec, field));
+			preCompleted.set(field, completed);
+			const depState = wrapAsDependencySourceState(completed, fieldParser);
+			if (depState) registerCompletedDependency(depState, registry);
+			continue;
+		}
+		if (fieldParser.dependencyMetadata?.source != null && isUnmatchedDependencyState(fieldState, fieldParser) && (annotatedFieldState !== fieldState || isNonCliBoundSourceState(fieldState, fieldParser))) {
+			const completed = await fieldParser.complete(annotatedFieldState, withChildExecPath(exec, field));
+			preCompleted.set(field, completed);
+			const depState = wrapAsDependencySourceState(completed, fieldParser);
+			if (depState) registerCompletedDependency(depState, registry);
+			continue;
+		}
 		if (Array.isArray(fieldState) && fieldState.length === 1 && isPendingDependencySourceState(fieldState[0])) {
-			const completed = await fieldParser.complete(fieldState, exec);
+			const completed = await fieldParser.complete(fieldState, withChildExecPath(exec, field));
 			preCompleted.set(field, completed);
 			if (isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
 		} else if (fieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState)) {
-			const completed = await fieldParser.complete([fieldParser.initialState], exec);
+			const completed = await fieldParser.complete([fieldParser.initialState], withChildExecPath(exec, field));
 			preCompleted.set(field, completed);
 			if (isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
 		} else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
 			const pendingState = fieldParser[wrappedDependencySourceMarker];
-			const completed = await fieldParser.complete([pendingState], exec);
+			const completed = await fieldParser.complete([pendingState], withChildExecPath(exec, field));
 			preCompleted.set(field, completed);
 			if (isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
 		} else if (fieldState != null && !Array.isArray(fieldState) && !isDependencySourceState(fieldState) && (isWrappedDependencySource(fieldParser) || isPendingDependencySourceState(fieldParser.initialState))) {
-			const annotatedFieldState = getAnnotatedFieldState(state, field, fieldParser);
-			const completed = await fieldParser.complete(annotatedFieldState, exec);
+			const annotatedFieldState$1 = getAnnotatedFieldState(state, field, fieldParser);
+			const completed = await fieldParser.complete(annotatedFieldState$1, withChildExecPath(exec, field));
 			preCompleted.set(field, completed);
 			const depState = wrapAsDependencySourceState(completed, fieldParser);
 			if (depState) registerCompletedDependency(depState, registry);
@@ -996,153 +1304,6 @@ async function preCompleteAndRegisterDependenciesAsync(state, fieldParserPairs,
 	}
 	return preCompleted;
 }
-/**
-* Recursively collects dependency values from DependencySourceState objects
-* found anywhere in the state tree.
-* @internal
-*/
-function collectDependencies(state, registry, visited = /* @__PURE__ */ new WeakSet()) {
-	if (state === null || state === void 0) return;
-	if (typeof state === "object") {
-		if (visited.has(state)) return;
-		visited.add(state);
-	}
-	if (isDependencySourceState(state)) {
-		const depId = state[dependencyId];
-		const result = state.result;
-		if (result.success) registry.set(depId, result.value);
-		return;
-	}
-	if (Array.isArray(state)) {
-		for (const item of state) collectDependencies(item, registry, visited);
-		return;
-	}
-	if (typeof state === "object" && !isDeferredParseState(state)) for (const key of Reflect.ownKeys(state)) collectDependencies(state[key], registry, visited);
-}
-/**
-* Checks if a value is a plain object (created with `{}` or `Object.create(null)`).
-* Class instances like `Temporal.PlainDate`, `URL`, `Date`, etc. return false.
-* This is used to determine whether to recursively traverse an object when
-* resolving deferred parse states - we only want to traverse plain objects
-* that are part of the parser state structure, not user values.
-*/
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
-}
-/**
-* Collects dependency values for a DeferredParseState from the registry.
-* Returns the collected values array, or null if any required dependency
-* is missing (and no default is available).
-*/
-function collectDependencyValues(deferredState, registry) {
-	const depIds = deferredState.dependencyIds;
-	if (depIds && depIds.length > 0) {
-		const defaults$1 = deferredState.defaultValues;
-		const dependencyValues = [];
-		for (let i = 0; i < depIds.length; i++) {
-			const depId$1 = depIds[i];
-			if (registry.has(depId$1)) dependencyValues.push(registry.get(depId$1));
-			else if (defaults$1 && i < defaults$1.length) dependencyValues.push(defaults$1[i]);
-			else return null;
-		}
-		return dependencyValues;
-	}
-	const depId = deferredState.dependencyId;
-	if (registry.has(depId)) return registry.get(depId);
-	const defaults = deferredState.defaultValues;
-	if (defaults && defaults.length > 0) return defaults[0];
-	return null;
-}
-/**
-* Recursively resolves DeferredParseState objects found anywhere in the state tree.
-* Returns the resolved state (sync version).
-*
-* Only traverses:
-* - DeferredParseState (to resolve it)
-* - DependencySourceState (skipped, kept as-is)
-* - Arrays (to find nested deferred states)
-* - Plain objects (to find nested deferred states in parser state structures)
-*
-* Does NOT traverse class instances (e.g., Temporal.PlainDate, URL) since these
-* are user values that should be preserved as-is.
-*/
-function resolveDeferred(state, registry, visited = /* @__PURE__ */ new WeakSet()) {
-	if (state === null || state === void 0) return state;
-	if (typeof state === "object") {
-		if (visited.has(state)) return state;
-		visited.add(state);
-	}
-	if (isDeferredParseState(state)) {
-		const deferredState = state;
-		const dependencyValue = collectDependencyValues(deferredState, registry);
-		if (dependencyValue === null) return deferredState.preliminaryResult;
-		const reParseResult = deferredState.parser[parseWithDependency](deferredState.rawInput, dependencyValue);
-		if (reParseResult instanceof Promise) return deferredState.preliminaryResult;
-		return reParseResult;
-	}
-	if (isDependencySourceState(state)) return state;
-	if (Array.isArray(state)) return state.map((item) => resolveDeferred(item, registry, visited));
-	if (isPlainObject(state)) {
-		const resolved = {};
-		for (const key of Reflect.ownKeys(state)) resolved[key] = resolveDeferred(state[key], registry, visited);
-		return resolved;
-	}
-	return state;
-}
-function resolveDeferredParseStates(fieldStates, initialRegistry) {
-	const registry = initialRegistry ?? new DependencyRegistry();
-	collectDependencies(fieldStates, registry);
-	return resolveDeferred(fieldStates, registry);
-}
-/**
-* Recursively resolves DeferredParseState objects found anywhere in the state tree.
-* Returns the resolved state (async version).
-*
-* Only traverses:
-* - DeferredParseState (to resolve it)
-* - DependencySourceState (skipped, kept as-is)
-* - Arrays (to find nested deferred states)
-* - Plain objects (to find nested deferred states in parser state structures)
-*
-* Does NOT traverse class instances (e.g., Temporal.PlainDate, URL) since these
-* are user values that should be preserved as-is.
-*/
-async function resolveDeferredAsync(state, registry, visited = /* @__PURE__ */ new WeakSet()) {
-	if (state === null || state === void 0) return state;
-	if (typeof state === "object") {
-		if (visited.has(state)) return state;
-		visited.add(state);
-	}
-	if (isDeferredParseState(state)) {
-		const deferredState = state;
-		const dependencyValue = collectDependencyValues(deferredState, registry);
-		if (dependencyValue === null) return deferredState.preliminaryResult;
-		const reParseResult = deferredState.parser[parseWithDependency](deferredState.rawInput, dependencyValue);
-		return Promise.resolve(reParseResult);
-	}
-	if (isDependencySourceState(state)) return state;
-	if (Array.isArray(state)) return Promise.all(state.map((item) => resolveDeferredAsync(item, registry, visited)));
-	if (isPlainObject(state)) {
-		const resolved = {};
-		const keys = Reflect.ownKeys(state);
-		await Promise.all(keys.map(async (key) => {
-			resolved[key] = await resolveDeferredAsync(state[key], registry, visited);
-		}));
-		return resolved;
-	}
-	return state;
-}
-/**
-* Async version of resolveDeferredParseStates for async parsers.
-* @internal
-*/
-async function resolveDeferredParseStatesAsync(fieldStates, initialRegistry) {
-	const registry = initialRegistry ?? new DependencyRegistry();
-	collectDependencies(fieldStates, registry);
-	return await resolveDeferredAsync(fieldStates, registry);
-}
 function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	const label = typeof labelOrParsers === "string" ? labelOrParsers : void 0;
 	if (label != null) validateLabel(label);
@@ -1164,7 +1325,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		return state;
 	};
 	const inheritedFieldStateCache = /* @__PURE__ */ new WeakMap();
-	const createFieldStateGetter = (parentState) => {
+	const createFieldStateGetter = (parentState, annotateChildState = getAnnotatedChildState) => {
 		return (field, parser) => {
 			const fieldKey = field;
 			const cache = parentState != null && typeof parentState === "object" ? inheritedFieldStateCache.get(parentState) ?? (() => {
@@ -1174,16 +1335,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			})() : void 0;
 			if (cache?.has(fieldKey)) return cache.get(fieldKey);
 			const sourceState = parentState != null && typeof parentState === "object" && fieldKey in parentState ? parentState[fieldKey] : parser.initialState;
-			if (sourceState == null || typeof sourceState !== "object") {
-				cache?.set(fieldKey, sourceState);
-				return sourceState;
-			}
-			const annotations = getAnnotations(parentState);
-			if (annotations === void 0 || getAnnotations(sourceState) === annotations) {
-				cache?.set(fieldKey, sourceState);
-				return sourceState;
-			}
-			const inheritedState = Reflect.get(parser, inheritParentAnnotationsKey) === true ? injectAnnotations(sourceState, annotations) : inheritAnnotations(parentState, sourceState);
+			const inheritedState = annotateChildState(parentState, sourceState, parser);
 			cache?.set(fieldKey, inheritedState);
 			return inheritedState;
 		};
@@ -1212,21 +1364,24 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		let madeProgress = true;
 		while (madeProgress && currentContext.buffer.length > 0) {
 			madeProgress = false;
-			const getFieldState = createFieldStateGetter(currentContext.state);
+			const getFieldState = createFieldStateGetter(currentContext.state, getObjectParseChildState);
 			for (const [field, parser] of parserPairs) {
-				const result = parser.parse({
-					...currentContext,
-					state: getFieldState(field, parser)
-				});
+				const result = parser.parse(withChildContext(currentContext, field, getFieldState(field, parser)));
 				if (result.success && result.consumed.length > 0) {
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: {
 							...currentContext.state,
-							[field]: result.next.state
-						}
+							[field]: getAnnotatedChildState(currentContext.state, result.next.state, parser)
+						},
+						...mergedExec != null ? {
+							trace: mergedExec.trace,
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					allConsumed.push(...result.consumed);
 					anySuccess = true;
@@ -1245,7 +1400,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			const getFieldState = createFieldStateGetter(context.state);
 			for (const [field, parser] of parserPairs) {
 				const fieldState = getFieldState(field, parser);
-				const completeResult = parser.complete(fieldState, context.exec);
+				const completeResult = parser.complete(fieldState, withChildExecPath(context.exec, field));
 				if (!completeResult.success) {
 					allCanComplete = false;
 					break;
@@ -1270,22 +1425,25 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		let madeProgress = true;
 		while (madeProgress && currentContext.buffer.length > 0) {
 			madeProgress = false;
-			const getFieldState = createFieldStateGetter(currentContext.state);
+			const getFieldState = createFieldStateGetter(currentContext.state, getObjectParseChildState);
 			for (const [field, parser] of parserPairs) {
-				const resultOrPromise = parser.parse({
-					...currentContext,
-					state: getFieldState(field, parser)
-				});
+				const resultOrPromise = parser.parse(withChildContext(currentContext, field, getFieldState(field, parser)));
 				const result = await resultOrPromise;
 				if (result.success && result.consumed.length > 0) {
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
 						state: {
 							...currentContext.state,
-							[field]: result.next.state
-						}
+							[field]: getAnnotatedChildState(currentContext.state, result.next.state, parser)
+						},
+						...mergedExec != null ? {
+							trace: mergedExec.trace,
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					allConsumed.push(...result.consumed);
 					anySuccess = true;
@@ -1304,7 +1462,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			const getFieldState = createFieldStateGetter(context.state);
 			for (const [field, parser] of parserPairs) {
 				const fieldState = getFieldState(field, parser);
-				const completeResult = await parser.complete(fieldState, context.exec);
+				const completeResult = await parser.complete(fieldState, withChildExecPath(context.exec, field));
 				if (!completeResult.success) {
 					allCanComplete = false;
 					break;
@@ -1343,7 +1501,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					...exec,
 					dependencyRuntime: runtime
 				};
-				const typedParserPairs = parserPairs;
+				const typedParserPairs = filterExcludedFieldParsers(parserPairs, exec?.excludedSourceFields);
 				const preCompleted = preCompleteAndRegisterDependencies(state, typedParserPairs, runtime.registry, childExec);
 				const phase3Exec = {
 					...childExec,
@@ -1356,6 +1514,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					const fieldParser = parsers[field];
 					annotatedState[fieldKey] = getFieldState(field, fieldParser);
 				}
+				collectExplicitSourceValues(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromPairs(typedParserPairs, annotatedState, exec?.path), new Set(preCompleted.keys())), runtime);
 				const resolvedFieldStates = resolveStateWithRuntime(annotatedState, runtime);
 				const result = {};
 				const deferredKeys = /* @__PURE__ */ new Map();
@@ -1368,7 +1527,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
 					else {
 						const fieldState = resolvedFieldStates[fieldKey];
-						valueResult = unwrapCompleteResult(fieldParser.complete(fieldState, phase3Exec));
+						valueResult = unwrapCompleteResult(fieldParser.complete(fieldState, withChildExecPath(phase3Exec, fieldKey)));
 					}
 					if (valueResult.success) {
 						result[fieldKey] = valueResult.value;
@@ -1395,7 +1554,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					...exec,
 					dependencyRuntime: runtime
 				};
-				const asyncParserPairs = parserPairs;
+				const asyncParserPairs = filterExcludedFieldParsers(parserPairs, exec?.excludedSourceFields);
 				const preCompleted = await preCompleteAndRegisterDependenciesAsync(state, asyncParserPairs, runtime.registry, childExec);
 				const phase3Exec = {
 					...childExec,
@@ -1408,20 +1567,12 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					const fieldParser = parsers[field];
 					annotatedState[fieldKey] = getFieldState(field, fieldParser);
 				}
+				await collectExplicitSourceValuesAsync(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromPairs(asyncParserPairs, annotatedState, exec?.path), new Set(preCompleted.keys())), runtime);
 				const resolvedFieldStates = await resolveStateWithRuntimeAsync(annotatedState, runtime);
 				const result = {};
 				const deferredKeys = /* @__PURE__ */ new Map();
 				let hasDeferred = false;
-				for (const field of parserKeys) {
-					const fieldKey = field;
-					const fieldParser = parsers[field];
-					let valueResult;
-					const preCompletedResult = preCompleted.get(fieldKey);
-					if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
-					else {
-						const fieldState = resolvedFieldStates[fieldKey];
-						valueResult = unwrapCompleteResult(await fieldParser.complete(fieldState, phase3Exec));
-					}
+				const applyValueResult = (fieldKey, valueResult) => {
 					if (valueResult.success) {
 						result[fieldKey] = valueResult.value;
 						if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(fieldKey, valueResult.deferredKeys);
@@ -1431,6 +1582,41 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 						success: false,
 						error: valueResult.error
 					};
+					return void 0;
+				};
+				const concurrentFields = [];
+				const deferredFields = [];
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldParser = parsers[field];
+					const preCompletedResult = preCompleted.get(fieldKey);
+					if (preCompletedResult !== void 0) {
+						const failure = applyValueResult(fieldKey, unwrapCompleteResult(preCompletedResult));
+						if (failure != null) return failure;
+						continue;
+					}
+					if (typeof fieldParser.shouldDeferCompletion === "function" && fieldParser.shouldDeferCompletion(resolvedFieldStates[fieldKey], withChildExecPath(phase3Exec, fieldKey)) === true) deferredFields.push(field);
+					else concurrentFields.push(field);
+				}
+				const concurrentResults = await Promise.all(concurrentFields.map(async (field) => {
+					const fieldKey = field;
+					const fieldParser = parsers[field];
+					const valueResult = unwrapCompleteResult(await fieldParser.complete(resolvedFieldStates[fieldKey], withChildExecPath(phase3Exec, fieldKey)));
+					return {
+						fieldKey,
+						valueResult
+					};
+				}));
+				for (const { fieldKey, valueResult } of concurrentResults) {
+					const failure = applyValueResult(fieldKey, valueResult);
+					if (failure != null) return failure;
+				}
+				for (const field of deferredFields) {
+					const fieldKey = field;
+					const fieldParser = parsers[field];
+					const valueResult = unwrapCompleteResult(await fieldParser.complete(resolvedFieldStates[fieldKey], withChildExecPath(phase3Exec, fieldKey)));
+					const failure = applyValueResult(fieldKey, valueResult);
+					if (failure != null) return failure;
 				}
 				const isDeferred = deferredKeys.size > 0 || hasDeferred;
 				return {
@@ -1498,37 +1684,226 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		configurable: true,
 		enumerable: false
 	});
+	defineInheritedAnnotationParser(objectParser);
 	return objectParser;
 }
 function suggestTupleSync(context, prefix, parsers) {
 	const suggestions = [];
-	const stateArray = context.state;
+	const advanced = advanceTupleSuggestContextSync(context, parsers);
+	const advancedContext = advanced.context;
+	const stateArray = advancedContext.state;
+	const runtime = createDependencyRuntimeContext(advancedContext.dependencyRegistry?.clone());
+	if (stateArray && Array.isArray(stateArray)) {
+		const nodes = buildSuggestRuntimeNodesFromArray(parsers, stateArray, advancedContext.exec?.path);
+		collectExplicitSourceValues(nodes, runtime);
+		fillMissingSourceDefaults(nodes, runtime);
+		collectSourcesFromState(stateArray, runtime);
+		completeDependencySourceDefaults({
+			...advancedContext,
+			state: createAnnotatedArrayStateRecord(stateArray)
+		}, buildIndexedParserPairs(parsers), runtime.registry, advancedContext.exec);
+	}
+	markFailedTupleSuggestSources(parsers, stateArray, advanced.failedParserIndexes, runtime, advancedContext.exec?.path);
+	const contextWithRegistry = {
+		...advancedContext,
+		dependencyRegistry: runtime.registry,
+		...advancedContext.exec != null ? { exec: {
+			...advancedContext.exec,
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		} } : {}
+	};
 	for (let i = 0; i < parsers.length; i++) {
 		const parser = parsers[i];
 		const parserState = stateArray && Array.isArray(stateArray) ? stateArray[i] : parser.initialState;
-		const parserSuggestions = parser.suggest({
-			...context,
-			state: parserState
-		}, prefix);
+		const parserSuggestions = parser.suggest(withChildContext(contextWithRegistry, i, parserState, parser), prefix);
 		suggestions.push(...parserSuggestions);
 	}
 	return deduplicateSuggestions(suggestions);
 }
 async function* suggestTupleAsync(context, prefix, parsers) {
 	const suggestions = [];
-	const stateArray = context.state;
+	const advanced = await advanceTupleSuggestContextAsync(context, parsers);
+	const advancedContext = advanced.context;
+	const stateArray = advancedContext.state;
+	const runtime = createDependencyRuntimeContext(advancedContext.dependencyRegistry?.clone());
+	if (stateArray && Array.isArray(stateArray)) {
+		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);
+	}
+	markFailedTupleSuggestSources(parsers, stateArray, advanced.failedParserIndexes, runtime, advancedContext.exec?.path);
+	const contextWithRegistry = {
+		...advancedContext,
+		dependencyRegistry: runtime.registry,
+		...advancedContext.exec != null ? { exec: {
+			...advancedContext.exec,
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		} } : {}
+	};
 	for (let i = 0; i < parsers.length; i++) {
 		const parser = parsers[i];
 		const parserState = stateArray && Array.isArray(stateArray) ? stateArray[i] : parser.initialState;
-		const parserSuggestions = parser.suggest({
-			...context,
-			state: parserState
-		}, prefix);
+		const parserSuggestions = parser.suggest(withChildContext(contextWithRegistry, i, parserState, parser), prefix);
 		if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
 		else suggestions.push(...parserSuggestions);
 	}
 	yield* deduplicateSuggestions(suggestions);
 }
+function advanceTupleSuggestContextSync(context, parsers) {
+	let currentContext = context;
+	const matchedParsers = /* @__PURE__ */ new Set();
+	while (currentContext.buffer.length > 0 && matchedParsers.size < parsers.length) {
+		let foundMatch = false;
+		let failedParserIndexes = [];
+		let deepestFailure = 0;
+		const stateArray = Array.isArray(currentContext.state) ? [...currentContext.state] : parsers.map((parser) => parser.initialState);
+		const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+		for (const [parser, index] of remainingParsers) {
+			const result = parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
+			if (result.success && result.consumed.length > 0) {
+				const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((state, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : state));
+				const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+				currentContext = {
+					...currentContext,
+					buffer: result.next.buffer,
+					optionsTerminated: result.next.optionsTerminated,
+					state: newStateArray,
+					...mergedExec != null ? {
+						exec: mergedExec,
+						dependencyRegistry: mergedExec.dependencyRegistry
+					} : {}
+				};
+				matchedParsers.add(index);
+				foundMatch = true;
+				break;
+			} else if (!result.success && result.consumed > 0) {
+				if (result.consumed > deepestFailure) {
+					deepestFailure = result.consumed;
+					failedParserIndexes = [index];
+				} else if (result.consumed === deepestFailure) failedParserIndexes.push(index);
+			}
+		}
+		if (!foundMatch) for (const [parser, index] of remainingParsers) {
+			const result = parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
+			if (result.success && result.consumed.length < 1) {
+				const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((state, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : state));
+				const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+				currentContext = {
+					...currentContext,
+					state: newStateArray,
+					...mergedExec != null ? {
+						exec: mergedExec,
+						dependencyRegistry: mergedExec.dependencyRegistry
+					} : {}
+				};
+				matchedParsers.add(index);
+				foundMatch = true;
+				break;
+			} else if (!result.success && result.consumed < 1) {
+				matchedParsers.add(index);
+				foundMatch = true;
+				break;
+			}
+		}
+		if (!foundMatch) return {
+			context: currentContext,
+			failedParserIndexes
+		};
+	}
+	return {
+		context: currentContext,
+		failedParserIndexes: []
+	};
+}
+async function advanceTupleSuggestContextAsync(context, parsers) {
+	let currentContext = context;
+	const matchedParsers = /* @__PURE__ */ new Set();
+	while (currentContext.buffer.length > 0 && matchedParsers.size < parsers.length) {
+		let foundMatch = false;
+		let failedParserIndexes = [];
+		let deepestFailure = 0;
+		const stateArray = Array.isArray(currentContext.state) ? [...currentContext.state] : parsers.map((parser) => parser.initialState);
+		const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+		for (const [parser, index] of remainingParsers) {
+			const result = await parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
+			if (result.success && result.consumed.length > 0) {
+				const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((state, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : state));
+				const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+				currentContext = {
+					...currentContext,
+					buffer: result.next.buffer,
+					optionsTerminated: result.next.optionsTerminated,
+					state: newStateArray,
+					...mergedExec != null ? {
+						exec: mergedExec,
+						dependencyRegistry: mergedExec.dependencyRegistry
+					} : {}
+				};
+				matchedParsers.add(index);
+				foundMatch = true;
+				break;
+			} else if (!result.success && result.consumed > 0) {
+				if (result.consumed > deepestFailure) {
+					deepestFailure = result.consumed;
+					failedParserIndexes = [index];
+				} else if (result.consumed === deepestFailure) failedParserIndexes.push(index);
+			}
+		}
+		if (!foundMatch) for (const [parser, index] of remainingParsers) {
+			const result = await parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
+			if (result.success && result.consumed.length < 1) {
+				const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((state, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : state));
+				const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+				currentContext = {
+					...currentContext,
+					state: newStateArray,
+					...mergedExec != null ? {
+						exec: mergedExec,
+						dependencyRegistry: mergedExec.dependencyRegistry
+					} : {}
+				};
+				matchedParsers.add(index);
+				foundMatch = true;
+				break;
+			} else if (!result.success && result.consumed < 1) {
+				matchedParsers.add(index);
+				foundMatch = true;
+				break;
+			}
+		}
+		if (!foundMatch) return {
+			context: currentContext,
+			failedParserIndexes
+		};
+	}
+	return {
+		context: currentContext,
+		failedParserIndexes: []
+	};
+}
+function markFailedTupleSuggestSources(parsers, stateArray, failedParserIndexes, runtime, parentPath) {
+	if (failedParserIndexes.length < 1) return;
+	const prefix = parentPath ?? [];
+	const failedSourceIds = /* @__PURE__ */ new Set();
+	for (const index of failedParserIndexes) {
+		const parser = parsers[index];
+		if (parser == null) continue;
+		const parserState = stateArray && Array.isArray(stateArray) ? stateArray[index] : parser.initialState;
+		const nodes = getParserSuggestRuntimeNodes(parser, getAnnotatedChildState(stateArray, parserState, parser), [...prefix, index]);
+		for (const node of nodes) {
+			const sourceId = node.parser.dependencyMetadata?.source?.sourceId;
+			if (sourceId != null) failedSourceIds.add(sourceId);
+		}
+	}
+	for (const sourceId of failedSourceIds) runtime.markSourceFailed(sourceId);
+}
 function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	const label = typeof labelOrParsers === "string" ? labelOrParsers : void 0;
 	if (label != null) validateLabel(label);
@@ -1557,17 +1932,19 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			const stateArray = currentContext.state;
 			const remainingParsers = syncParsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
 			for (const [parser, index] of remainingParsers) {
-				const result = parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
+				const result = parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
 				if (result.success && result.consumed.length > 0) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
+					const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : s));
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
-						state: newStateArray
+						state: newStateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					allConsumed.push(...result.consumed);
 					matchedParsers.add(index);
@@ -1576,15 +1953,17 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				} else if (!result.success && error.consumed < result.consumed) error = result;
 			}
 			if (!foundMatch) for (const [parser, index] of remainingParsers) {
-				const result = parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
+				const result = parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
 				if (result.success && result.consumed.length < 1) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
+					const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : s));
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
-						state: newStateArray
+						state: newStateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					matchedParsers.add(index);
 					foundMatch = true;
@@ -1619,18 +1998,20 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			const stateArray = currentContext.state;
 			const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
 			for (const [parser, index] of remainingParsers) {
-				const resultOrPromise = parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
+				const resultOrPromise = parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
 				const result = await resultOrPromise;
 				if (result.success && result.consumed.length > 0) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
+					const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : s));
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
-						state: newStateArray
+						state: newStateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					allConsumed.push(...result.consumed);
 					matchedParsers.add(index);
@@ -1639,16 +2020,18 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				} else if (!result.success && error.consumed < result.consumed) error = result;
 			}
 			if (!foundMatch) for (const [parser, index] of remainingParsers) {
-				const resultOrPromise = parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
+				const resultOrPromise = parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
 				const result = await resultOrPromise;
 				if (result.success && result.consumed.length < 1) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
+					const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : s));
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
-						state: newStateArray
+						state: newStateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					matchedParsers.add(index);
 					foundMatch = true;
@@ -1674,6 +2057,7 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
+		[fieldParsersKey]: parsers.map((parser, index) => [String(index), parser]),
 		usage: parsers.toSorted((a, b) => b.priority - a.priority).flatMap((p) => p.usage),
 		leadingNames: sharedBufferLeadingNames(parsers),
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
@@ -1690,9 +2074,10 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					...exec,
 					dependencyRuntime: runtime
 				};
-				const tuplePairs = syncParsers.map((p, i) => [String(i), p]);
-				const tupleState = Object.fromEntries(stateArray.map((s, i) => [String(i), s]));
+				const tuplePairs = buildIndexedParserPairs(syncParsers);
+				const tupleState = createAnnotatedArrayStateRecord(stateArray);
 				const preCompleted = preCompleteAndRegisterDependencies(tupleState, tuplePairs, runtime.registry, childExec);
+				collectExplicitSourceValues(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(syncParsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
 				const phase3Exec = {
 					...childExec,
 					preCompletedByParser: void 0
@@ -1708,7 +2093,7 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
 					else {
 						const elementState = prepareStateForCompletion(resolvedArray[i], elementParser);
-						valueResult = unwrapCompleteResult(elementParser.complete(elementState, phase3Exec));
+						valueResult = unwrapCompleteResult(elementParser.complete(elementState, withChildExecPath(phase3Exec, i)));
 					}
 					if (valueResult.success) {
 						result[i] = valueResult.value;
@@ -1736,9 +2121,10 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					...exec,
 					dependencyRuntime: runtime
 				};
-				const tuplePairs = parsers.map((p, i) => [String(i), p]);
-				const tupleState = Object.fromEntries(stateArray.map((s, i) => [String(i), s]));
+				const tuplePairs = buildIndexedParserPairs(parsers);
+				const tupleState = createAnnotatedArrayStateRecord(stateArray);
 				const preCompleted = await preCompleteAndRegisterDependenciesAsync(tupleState, tuplePairs, runtime.registry, childExec);
+				await collectExplicitSourceValuesAsync(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(parsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
 				const phase3Exec = {
 					...childExec,
 					preCompletedByParser: void 0
@@ -1754,7 +2140,7 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
 					else {
 						const elementState = prepareStateForCompletion(resolvedArray[i], elementParser);
-						valueResult = unwrapCompleteResult(await elementParser.complete(elementState, phase3Exec));
+						valueResult = unwrapCompleteResult(await elementParser.complete(elementState, withChildExecPath(phase3Exec, i)));
 					}
 					if (valueResult.success) {
 						result[i] = valueResult.value;
@@ -1834,6 +2220,7 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		configurable: true,
 		enumerable: false
 	});
+	defineInheritedAnnotationParser(tupleParser);
 	return tupleParser;
 }
 function merge(...args) {
@@ -1857,18 +2244,25 @@ 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 mergedFieldParsers = collectChildFieldParsers(parsers);
+	const duplicateOutputFieldNames = collectDuplicateFieldNames(mergedFieldParsers);
+	const parserStateKey = (index) => `__parser_${index}`;
+	const localObjectStateKey = (index) => `__merge_local_${index}`;
+	const shouldPreserveLocalChildState = (parser) => parser.initialState != null && typeof parser.initialState === "object" && Object.keys(parser.initialState).some((field) => duplicateOutputFieldNames.has(field));
 	const initialState = {};
 	for (let i = 0; i < parsers.length; i++) {
 		const parser = parsers[i];
-		if (parser.initialState === void 0) initialState[`__parser_${i}`] = void 0;
+		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) => {
 		if (parser.initialState === void 0) {
-			const key = `__parser_${index}`;
+			const key = parserStateKey(index);
 			if (context.state && typeof context.state === "object" && key in context.state) return context.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") {
 				const extractedState = {};
 				for (const field in parser.initialState) extractedState[field] = field in context.state ? context.state[field] : parser.initialState[field];
@@ -1878,9 +2272,9 @@ function merge(...args) {
 		}
 		return parser.initialState;
 	};
-	const mergeResultState = (parser, context, result, index) => {
+	const mergeResultState = (parser, context, parserState, result, index) => {
 		if (parser.initialState === void 0) {
-			const key = `__parser_${index}`;
+			const key = parserStateKey(index);
 			if (result.success) {
 				if (result.consumed.length > 0 || result.next.state !== void 0) return {
 					...context.state,
@@ -1889,10 +2283,17 @@ function merge(...args) {
 			}
 			return { ...context.state };
 		}
-		return result.success ? {
+		if (!result.success) return { ...context.state };
+		const mergedState = {
 			...context.state,
 			...result.next.state
-		} : { ...context.state };
+		};
+		if (!shouldPreserveLocalChildState(parser)) return mergedState;
+		if (result.consumed.length === 0 && result.next.state === parserState) return mergedState;
+		return {
+			...mergedState,
+			[localObjectStateKey(index)]: result.next.state
+		};
 	};
 	const parseSync = (context) => {
 		let currentContext = context;
@@ -1900,17 +2301,19 @@ function merge(...args) {
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
 			const parserState = extractParserState(parser, currentContext, i);
-			const result = parser.parse({
-				...currentContext,
-				state: parserState
-			});
+			const result = parser.parse(withChildContext(currentContext, i, parserState));
 			if (result.success) {
-				const newState = mergeResultState(parser, currentContext, result, i);
+				const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+				const newState = mergeResultState(parser, currentContext, parserState, result, i);
 				const newContext = {
 					...currentContext,
 					buffer: result.next.buffer,
 					optionsTerminated: result.next.optionsTerminated,
-					state: newState
+					state: newState,
+					...mergedExec != null ? {
+						exec: mergedExec,
+						dependencyRegistry: mergedExec.dependencyRegistry
+					} : {}
 				};
 				if (result.consumed.length > 0) return {
 					success: true,
@@ -1943,18 +2346,20 @@ function merge(...args) {
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
 			const parserState = extractParserState(parser, currentContext, i);
-			const resultOrPromise = parser.parse({
-				...currentContext,
-				state: parserState
-			});
+			const resultOrPromise = parser.parse(withChildContext(currentContext, i, parserState));
 			const result = await resultOrPromise;
 			if (result.success) {
-				const newState = mergeResultState(parser, currentContext, result, i);
+				const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
+				const newState = mergeResultState(parser, currentContext, parserState, result, i);
 				const newContext = {
 					...currentContext,
 					buffer: result.next.buffer,
 					optionsTerminated: result.next.optionsTerminated,
-					state: newState
+					state: newState,
+					...mergedExec != null ? {
+						exec: mergedExec,
+						dependencyRegistry: mergedExec.dependencyRegistry
+					} : {}
 				};
 				if (result.consumed.length > 0) return {
 					success: true,
@@ -1981,7 +2386,6 @@ function merge(...args) {
 			error: message`No matching option or argument found.`
 		};
 	};
-	const mergedFieldParsers = collectChildFieldParsers(parsers);
 	const mergeParser = {
 		$mode: combinedMode,
 		$valueType: [],
@@ -1999,10 +2403,12 @@ function merge(...args) {
 		complete(state, exec) {
 			const extractCompleteState = (parser, resolvedState, index) => {
 				if (parser.initialState === void 0) {
-					const key = `__parser_${index}`;
+					const key = parserStateKey(index);
 					if (resolvedState && typeof resolvedState === "object" && key in resolvedState) return resolvedState[key];
 					return void 0;
 				} else if (parser.initialState && typeof parser.initialState === "object") {
+					const key = localObjectStateKey(index);
+					if (shouldPreserveLocalChildState(parser) && resolvedState && typeof resolvedState === "object" && key in resolvedState) return resolvedState[key];
 					if (resolvedState && typeof resolvedState === "object") {
 						const extractedState = {};
 						for (const field in parser.initialState) extractedState[field] = field in resolvedState ? resolvedState[field] : parser.initialState[field];
@@ -2020,14 +2426,25 @@ function merge(...args) {
 					...exec,
 					dependencyRuntime: runtime
 				};
-				const perChildCache = syncParsers.map((parser) => {
+				const duplicateFieldNames = collectDuplicateFieldNames(mergedFieldParsers);
+				const unambiguousFieldParsers = filterDuplicateFieldParsers(mergedFieldParsers);
+				const perChildPhase1 = syncParsers.map((parser, i) => {
 					if (fieldParsersKey in parser) {
 						const pairs = parser[fieldParsersKey];
-						const preCompleted = preCompleteAndRegisterDependencies(state, pairs, runtime.registry, childExec);
-						return filterDuplicateKeys(preCompleted, pairs);
+						const excludedSourceFields = new Set(pairs.map(([field]) => field).filter((field) => duplicateFieldNames.has(field)));
+						const phase1Pairs = filterExcludedFieldParsers(pairs, excludedSourceFields);
+						const preCompleted = preCompleteAndRegisterDependencies(state, phase1Pairs, runtime.registry, withChildExecPath(childExec, i));
+						return {
+							cache: filterDuplicateKeys(preCompleted, phase1Pairs),
+							excludedSourceFields: excludedSourceFields.size > 0 ? excludedSourceFields : void 0
+						};
 					}
-					return void 0;
+					return {
+						cache: void 0,
+						excludedSourceFields: void 0
+					};
 				});
+				collectExplicitSourceValues(buildRuntimeNodesFromPairs(unambiguousFieldParsers, state, exec?.path), runtime);
 				const resolvedState = resolveStateWithRuntime(state, runtime);
 				const object$1 = {};
 				const deferredKeys = /* @__PURE__ */ new Map();
@@ -2035,11 +2452,21 @@ function merge(...args) {
 				for (let i = 0; i < syncParsers.length; i++) {
 					const parser = syncParsers[i];
 					const parserState = extractCompleteState(parser, resolvedState, i);
-					const cache = perChildCache[i];
-					const result = unwrapCompleteResult(parser.complete(parserState, {
-						...childExec,
+					const { cache, excludedSourceFields } = perChildPhase1[i];
+					const childCompleteExec = withChildExecPath(childExec, i);
+					const completeExec = excludedSourceFields == null ? {
+						...childCompleteExec,
 						preCompletedByParser: cache
-					}));
+					} : (() => {
+						const childRuntime = createDependencyRuntimeContext(runtime.registry.clone());
+						return {
+							...childCompleteExec,
+							dependencyRuntime: childRuntime,
+							dependencyRegistry: childRuntime.registry,
+							preCompletedByParser: cache
+						};
+					})();
+					const result = unwrapCompleteResult(parser.complete(parserState, completeExec));
 					if (!result.success) return result;
 					const resultValue = result.value;
 					for (const field in resultValue) {
@@ -2065,12 +2492,26 @@ function merge(...args) {
 					...exec,
 					dependencyRuntime: runtime
 				};
-				const perChildCache = [];
-				for (const parser of parsers) if (fieldParsersKey in parser) {
-					const pairs = parser[fieldParsersKey];
-					const preCompleted = await preCompleteAndRegisterDependenciesAsync(state, pairs, runtime.registry, childExec);
-					perChildCache.push(filterDuplicateKeys(preCompleted, pairs));
-				} else perChildCache.push(void 0);
+				const duplicateFieldNames = collectDuplicateFieldNames(mergedFieldParsers);
+				const unambiguousFieldParsers = filterDuplicateFieldParsers(mergedFieldParsers);
+				const perChildPhase1 = [];
+				for (let i = 0; i < parsers.length; i++) {
+					const parser = parsers[i];
+					if (fieldParsersKey in parser) {
+						const pairs = parser[fieldParsersKey];
+						const excludedSourceFields = new Set(pairs.map(([field]) => field).filter((field) => duplicateFieldNames.has(field)));
+						const phase1Pairs = filterExcludedFieldParsers(pairs, excludedSourceFields);
+						const preCompleted = await preCompleteAndRegisterDependenciesAsync(state, phase1Pairs, runtime.registry, withChildExecPath(childExec, i));
+						perChildPhase1.push({
+							cache: filterDuplicateKeys(preCompleted, phase1Pairs),
+							excludedSourceFields: excludedSourceFields.size > 0 ? excludedSourceFields : void 0
+						});
+					} else perChildPhase1.push({
+						cache: void 0,
+						excludedSourceFields: void 0
+					});
+				}
+				await collectExplicitSourceValuesAsync(buildRuntimeNodesFromPairs(unambiguousFieldParsers, state, exec?.path), runtime);
 				const resolvedState = await resolveStateWithRuntimeAsync(state, runtime);
 				const object$1 = {};
 				const deferredKeys = /* @__PURE__ */ new Map();
@@ -2078,11 +2519,21 @@ function merge(...args) {
 				for (let i = 0; i < parsers.length; i++) {
 					const parser = parsers[i];
 					const parserState = extractCompleteState(parser, resolvedState, i);
-					const asyncCache = perChildCache[i];
-					const result = unwrapCompleteResult(await parser.complete(parserState, {
-						...childExec,
+					const { cache: asyncCache, excludedSourceFields } = perChildPhase1[i];
+					const childCompleteExec = withChildExecPath(childExec, i);
+					const completeExec = excludedSourceFields == null ? {
+						...childCompleteExec,
 						preCompletedByParser: asyncCache
-					}));
+					} : (() => {
+						const childRuntime = createDependencyRuntimeContext(runtime.registry.clone());
+						return {
+							...childCompleteExec,
+							dependencyRuntime: childRuntime,
+							dependencyRegistry: childRuntime.registry,
+							preCompletedByParser: asyncCache
+						};
+					})();
+					const result = unwrapCompleteResult(await parser.complete(parserState, completeExec));
 					if (!result.success) return result;
 					const resultValue = result.value;
 					for (const field in resultValue) {
@@ -2107,10 +2558,12 @@ function merge(...args) {
 			if (options.hidden === true) return dispatchIterableByMode(combinedMode, function* () {}, async function* () {});
 			const extractState = (p, i) => {
 				if (p.initialState === void 0) {
-					const key = `__parser_${i}`;
+					const key = parserStateKey(i);
 					if (context.state && typeof context.state === "object" && key in context.state) return context.state[key];
 					return void 0;
 				} else if (p.initialState && typeof p.initialState === "object") {
+					const key = localObjectStateKey(i);
+					if (shouldPreserveLocalChildState(p) && context.state && typeof context.state === "object" && key in context.state) return context.state[key];
 					if (context.state && typeof context.state === "object") {
 						const extractedState = {};
 						for (const field in p.initialState) extractedState[field] = field in context.state ? context.state[field] : p.initialState[field];
@@ -2122,8 +2575,17 @@ function merge(...args) {
 			};
 			if (isAsync) return async function* () {
 				const runtime$1 = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
-				const childFieldPairs$1 = collectChildFieldParsers(parsers);
-				if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime$1);
+				const mergedPairs$1 = collectChildFieldParsers(parsers);
+				const duplicateFieldNames$1 = collectDuplicateFieldNames(mergedPairs$1);
+				const childFieldPairs$1 = filterDuplicateFieldParsers(mergedPairs$1);
+				const perChildExcludedSourceFields$1 = parsers.map((parser) => {
+					if (!(fieldParsersKey in parser)) return void 0;
+					const pairs = parser[fieldParsersKey];
+					const excludedSourceFields = new Set(pairs.map(([field]) => field).filter((field) => duplicateFieldNames$1.has(field)));
+					return excludedSourceFields.size > 0 ? excludedSourceFields : void 0;
+				});
+				if (context.state && typeof context.state === "object") await collectExplicitSourceValuesAsync(buildRuntimeNodesFromPairs(childFieldPairs$1, context.state, context.exec?.path), runtime$1);
+				if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime$1, /* @__PURE__ */ new WeakSet(), duplicateFieldNames$1);
 				await completeDependencySourceDefaultsAsync(context, childFieldPairs$1, runtime$1.registry, context.exec);
 				const contextWithRegistry$1 = {
 					...context,
@@ -2133,18 +2595,37 @@ function merge(...args) {
 				for (let i = 0; i < parsers.length; i++) {
 					const parser = parsers[i];
 					const parserState = extractState(parser, i);
-					const parserSuggestions = parser.suggest({
-						...contextWithRegistry$1,
-						state: parserState
-					}, prefix);
+					const childContext = withChildContext(contextWithRegistry$1, i, parserState);
+					const excludedSourceFields = perChildExcludedSourceFields$1[i];
+					const contextForChild = excludedSourceFields == null ? childContext : (() => {
+						const childRuntime = createDependencyRuntimeContext(runtime$1.registry.clone());
+						return {
+							...childContext,
+							dependencyRegistry: childRuntime.registry,
+							exec: childContext.exec == null ? childContext.exec : {
+								...childContext.exec,
+								dependencyRegistry: childRuntime.registry
+							}
+						};
+					})();
+					const parserSuggestions = parser.suggest(contextForChild, prefix);
 					if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
 					else suggestions.push(...parserSuggestions);
 				}
 				yield* deduplicateSuggestions(suggestions);
 			}();
 			const runtime = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
-			const childFieldPairs = collectChildFieldParsers(syncParsers);
-			if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime);
+			const mergedPairs = collectChildFieldParsers(syncParsers);
+			const duplicateFieldNames = collectDuplicateFieldNames(mergedPairs);
+			const childFieldPairs = filterDuplicateFieldParsers(mergedPairs);
+			const perChildExcludedSourceFields = syncParsers.map((parser) => {
+				if (!(fieldParsersKey in parser)) return void 0;
+				const pairs = parser[fieldParsersKey];
+				const excludedSourceFields = new Set(pairs.map(([field]) => field).filter((field) => duplicateFieldNames.has(field)));
+				return excludedSourceFields.size > 0 ? excludedSourceFields : void 0;
+			});
+			if (context.state && typeof context.state === "object") collectExplicitSourceValues(buildRuntimeNodesFromPairs(childFieldPairs, context.state, context.exec?.path), runtime);
+			if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime, /* @__PURE__ */ new WeakSet(), duplicateFieldNames);
 			completeDependencySourceDefaults(context, childFieldPairs, runtime.registry, context.exec);
 			const contextWithRegistry = {
 				...context,
@@ -2155,10 +2636,20 @@ function merge(...args) {
 				for (let i = 0; i < syncParsers.length; i++) {
 					const parser = syncParsers[i];
 					const parserState = extractState(parser, i);
-					const parserSuggestions = parser.suggest({
-						...contextWithRegistry,
-						state: parserState
-					}, prefix);
+					const childContext = withChildContext(contextWithRegistry, i, parserState);
+					const excludedSourceFields = perChildExcludedSourceFields[i];
+					const contextForChild = excludedSourceFields == null ? childContext : (() => {
+						const childRuntime = createDependencyRuntimeContext(runtime.registry.clone());
+						return {
+							...childContext,
+							dependencyRegistry: childRuntime.registry,
+							exec: childContext.exec == null ? childContext.exec : {
+								...childContext.exec,
+								dependencyRegistry: childRuntime.registry
+							}
+						};
+					})();
+					const parserSuggestions = parser.suggest(contextForChild, prefix);
 					suggestions.push(...parserSuggestions);
 				}
 				yield* deduplicateSuggestions(suggestions);
@@ -2225,6 +2716,7 @@ function merge(...args) {
 			};
 		}
 	};
+	defineInheritedAnnotationParser(mergeParser);
 	return mergeParser;
 }
 /**
@@ -2233,18 +2725,126 @@ function merge(...args) {
 * async branches of `concat().suggest()`.
 * @internal
 */
-function buildSuggestRegistry(preParsedContext) {
+function buildSuggestRegistry(preParsedContext, parsers) {
 	const stateArray = preParsedContext.state;
 	const runtime = createDependencyRuntimeContext(preParsedContext.dependencyRegistry?.clone());
-	if (stateArray && Array.isArray(stateArray)) collectSourcesFromState(stateArray, runtime);
+	if (stateArray && Array.isArray(stateArray)) {
+		const nodes = buildSuggestRuntimeNodesFromArray(parsers, stateArray, preParsedContext.exec?.path);
+		collectExplicitSourceValues(nodes, runtime);
+		fillMissingSourceDefaults(nodes, runtime);
+		collectSourcesFromState(stateArray, runtime);
+		completeDependencySourceDefaults({
+			...preParsedContext,
+			state: createAnnotatedArrayStateRecord(stateArray)
+		}, buildIndexedParserPairs(parsers), runtime.registry, preParsedContext.exec);
+		const prefix = preParsedContext.exec?.path ?? [];
+		for (let i = 0; i < parsers.length; i++) seedSuggestRuntimeFromFieldParsers(parsers[i], getAnnotatedChildState(stateArray, stateArray[i], parsers[i]), runtime, [...prefix, i]);
+	}
 	return {
 		context: {
 			...preParsedContext,
-			dependencyRegistry: runtime.registry
+			dependencyRegistry: runtime.registry,
+			...preParsedContext.exec != null ? { exec: {
+				...preParsedContext.exec,
+				dependencyRuntime: runtime,
+				dependencyRegistry: runtime.registry
+			} } : {}
+		},
+		stateArray
+	};
+}
+async function buildSuggestRegistryAsync(preParsedContext, parsers) {
+	const stateArray = preParsedContext.state;
+	const runtime = createDependencyRuntimeContext(preParsedContext.dependencyRegistry?.clone());
+	if (stateArray && Array.isArray(stateArray)) {
+		const nodes = buildSuggestRuntimeNodesFromArray(parsers, stateArray, preParsedContext.exec?.path);
+		await collectExplicitSourceValuesAsync(nodes, runtime);
+		await fillMissingSourceDefaultsAsync(nodes, runtime);
+		collectSourcesFromState(stateArray, runtime);
+		await completeDependencySourceDefaultsAsync({
+			...preParsedContext,
+			state: createAnnotatedArrayStateRecord(stateArray)
+		}, buildIndexedParserPairs(parsers), runtime.registry, preParsedContext.exec);
+		const prefix = preParsedContext.exec?.path ?? [];
+		for (let i = 0; i < parsers.length; i++) await seedSuggestRuntimeFromFieldParsersAsync(parsers[i], getAnnotatedChildState(stateArray, stateArray[i], parsers[i]), runtime, [...prefix, i]);
+	}
+	return {
+		context: {
+			...preParsedContext,
+			dependencyRegistry: runtime.registry,
+			...preParsedContext.exec != null ? { exec: {
+				...preParsedContext.exec,
+				dependencyRuntime: runtime,
+				dependencyRegistry: runtime.registry
+			} } : {}
 		},
 		stateArray
 	};
 }
+function seedSuggestRuntimeFromFieldParsers(parser, state, runtime, parentPath) {
+	if (!(fieldParsersKey in parser)) return;
+	const rawPairs = parser[fieldParsersKey];
+	const duplicateFieldNames = collectDuplicateFieldNames(rawPairs);
+	const pairs = filterDuplicateFieldParsers(rawPairs);
+	const stateRecord = state != null && typeof state === "object" ? state : {};
+	const nodes = buildSuggestRuntimeNodesFromPairs(pairs, stateRecord, parentPath);
+	collectExplicitSourceValues(nodes, runtime);
+	fillMissingSourceDefaults(nodes, runtime);
+	collectSourcesFromState(state, runtime, /* @__PURE__ */ new WeakSet(), duplicateFieldNames);
+	completeDependencySourceDefaults({
+		buffer: [],
+		optionsTerminated: false,
+		state: stateRecord,
+		usage: parser.usage,
+		dependencyRegistry: runtime.registry,
+		exec: {
+			usage: parser.usage,
+			phase: "suggest",
+			path: parentPath,
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		}
+	}, pairs, runtime.registry, {
+		usage: parser.usage,
+		phase: "suggest",
+		path: parentPath,
+		dependencyRuntime: runtime,
+		dependencyRegistry: runtime.registry
+	});
+	for (const [field, childParser] of pairs) seedSuggestRuntimeFromFieldParsers(childParser, getAnnotatedFieldState(stateRecord, field, childParser), runtime, [...parentPath, field]);
+}
+async function seedSuggestRuntimeFromFieldParsersAsync(parser, state, runtime, parentPath) {
+	if (!(fieldParsersKey in parser)) return;
+	const rawPairs = parser[fieldParsersKey];
+	const duplicateFieldNames = collectDuplicateFieldNames(rawPairs);
+	const pairs = filterDuplicateFieldParsers(rawPairs);
+	const stateRecord = state != null && typeof state === "object" ? state : {};
+	const nodes = buildSuggestRuntimeNodesFromPairs(pairs, stateRecord, parentPath);
+	await collectExplicitSourceValuesAsync(nodes, runtime);
+	await fillMissingSourceDefaultsAsync(nodes, runtime);
+	collectSourcesFromState(state, runtime, /* @__PURE__ */ new WeakSet(), duplicateFieldNames);
+	await completeDependencySourceDefaultsAsync({
+		buffer: [],
+		optionsTerminated: false,
+		state: stateRecord,
+		usage: parser.usage,
+		dependencyRegistry: runtime.registry,
+		exec: {
+			usage: parser.usage,
+			phase: "suggest",
+			path: parentPath,
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		}
+	}, pairs, runtime.registry, {
+		usage: parser.usage,
+		phase: "suggest",
+		path: parentPath,
+		dependencyRuntime: runtime,
+		dependencyRegistry: runtime.registry
+	});
+	for (const [field, childParser] of pairs) await seedSuggestRuntimeFromFieldParsersAsync(childParser, getAnnotatedFieldState(stateRecord, field, childParser), runtime, [...parentPath, field]);
+}
 /**
 * This helper replays child parsers in priority order (mirroring
 * `concat.parse()`) to accumulate dependency source values for suggestions.
@@ -2252,7 +2852,7 @@ function buildSuggestRegistry(preParsedContext) {
 */
 function preParseSuggestContext(context, parsers) {
 	if (context.buffer.length < 1 || !Array.isArray(context.state)) return context;
-	return preParseSuggestLoop(context, context.state.slice(), parsers);
+	return preParseSuggestLoop(context, annotateFreshArray(context.state, context.state.slice()), parsers);
 }
 /**
 * Async variant of {@link preParseSuggestContext} that awaits async child
@@ -2261,7 +2861,7 @@ function preParseSuggestContext(context, parsers) {
 */
 async function preParseSuggestContextAsync(context, parsers) {
 	if (context.buffer.length < 1 || !Array.isArray(context.state)) return context;
-	return await preParseSuggestLoop(context, context.state.slice(), parsers);
+	return await preParseSuggestLoop(context, annotateFreshArray(context.state, context.state.slice()), parsers);
 }
 /**
 * Shared loop for sync and async concat suggest pre-parse.  When a child
@@ -2297,21 +2897,23 @@ function tryParseSuggestList(context, stateArray, parsers, matchedParsers, remai
 	for (let ri = 0; ri < remaining.length; ri++) {
 		const [parser, index] = remaining[ri];
 		const parserState = index < stateArray.length ? stateArray[index] : parser.initialState;
-		const resultOrPromise = parser.parse({
-			...context,
-			state: parserState
-		});
+		const resultOrPromise = parser.parse(withChildContext(context, index, parserState, parser));
 		if (resultOrPromise != null && typeof resultOrPromise === "object" && "then" in resultOrPromise && typeof resultOrPromise.then === "function") {
 			const tail = remaining.slice(ri + 1);
 			return resultOrPromise.then((result$1) => {
 				if (result$1.success && result$1.consumed.length > 0) {
-					stateArray[index] = result$1.next.state;
+					stateArray[index] = getAnnotatedChildState(context.state, result$1.next.state, parser);
 					matchedParsers.add(index);
+					const mergedExec = mergeChildExec(context.exec, result$1.next.exec);
 					return preParseSuggestLoop({
 						...context,
 						buffer: result$1.next.buffer,
 						optionsTerminated: result$1.next.optionsTerminated,
-						state: stateArray
+						state: stateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					}, stateArray, parsers, matchedParsers);
 				}
 				const next = tryParseSuggestList(context, stateArray, parsers, matchedParsers, tail);
@@ -2327,13 +2929,18 @@ function tryParseSuggestList(context, stateArray, parsers, matchedParsers, remai
 		}
 		const result = resultOrPromise;
 		if (result.success && result.consumed.length > 0) {
-			stateArray[index] = result.next.state;
+			stateArray[index] = getAnnotatedChildState(context.state, result.next.state, parser);
 			matchedParsers.add(index);
+			const mergedExec = mergeChildExec(context.exec, result.next.exec);
 			return {
 				...context,
 				buffer: result.next.buffer,
 				optionsTerminated: result.next.optionsTerminated,
-				state: stateArray
+				state: stateArray,
+				...mergedExec != null ? {
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
 			};
 		}
 	}
@@ -2359,17 +2966,19 @@ function concat(...parsers) {
 			const stateArray = currentContext.state;
 			const remainingParsers = syncParsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
 			for (const [parser, index] of remainingParsers) {
-				const result = parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
+				const result = parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
 				if (result.success && result.consumed.length > 0) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
+					const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : s));
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
-						state: newStateArray
+						state: newStateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					allConsumed.push(...result.consumed);
 					matchedParsers.add(index);
@@ -2378,15 +2987,17 @@ function concat(...parsers) {
 				} else if (!result.success && error.consumed < result.consumed) error = result;
 			}
 			if (!foundMatch) for (const [parser, index] of remainingParsers) {
-				const result = parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
+				const result = parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
 				if (result.success && result.consumed.length < 1) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
+					const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : s));
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
-						state: newStateArray
+						state: newStateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					matchedParsers.add(index);
 					foundMatch = true;
@@ -2421,17 +3032,19 @@ function concat(...parsers) {
 			const stateArray = currentContext.state;
 			const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
 			for (const [parser, index] of remainingParsers) {
-				const result = await parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
+				const result = await parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
 				if (result.success && result.consumed.length > 0) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
+					const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : s));
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
 						buffer: result.next.buffer,
 						optionsTerminated: result.next.optionsTerminated,
-						state: newStateArray
+						state: newStateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					allConsumed.push(...result.consumed);
 					matchedParsers.add(index);
@@ -2440,15 +3053,17 @@ function concat(...parsers) {
 				} else if (!result.success && error.consumed < result.consumed) error = result;
 			}
 			if (!foundMatch) for (const [parser, index] of remainingParsers) {
-				const result = await parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
+				const result = await parser.parse(withChildContext(currentContext, index, stateArray[index], parser));
 				if (result.success && result.consumed.length < 1) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
+					const newStateArray = annotateFreshArray(currentContext.state, stateArray.map((s, idx) => idx === index ? getAnnotatedChildState(currentContext.state, result.next.state, parser) : s));
+					const mergedExec = mergeChildExec(currentContext.exec, result.next.exec);
 					currentContext = {
 						...currentContext,
-						state: newStateArray
+						state: newStateArray,
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
 					};
 					matchedParsers.add(index);
 					foundMatch = true;
@@ -2475,7 +3090,14 @@ function concat(...parsers) {
 		const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
 		const childExec = {
 			...exec,
-			dependencyRuntime: runtime,
+			dependencyRuntime: runtime
+		};
+		const concatPairs = buildIndexedParserPairs(syncParsers);
+		const concatState = createAnnotatedArrayStateRecord(stateArray);
+		const preCompleted = preCompleteAndRegisterDependencies(concatState, concatPairs, 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);
@@ -2484,8 +3106,8 @@ function concat(...parsers) {
 		let hasDeferred = false;
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
-			const parserState = prepareStateForCompletion(resolvedArray[i], parser);
-			const result = unwrapCompleteResult(parser.complete(parserState, childExec));
+			const preCompletedResult = preCompleted.get(String(i));
+			const result = preCompletedResult !== void 0 ? unwrapCompleteResult(preCompletedResult) : unwrapCompleteResult(parser.complete(prepareStateForCompletion(resolvedArray[i], parser), withChildExecPath(phase3Exec, i)));
 			if (!result.success) return result;
 			const baseIndex = results.length;
 			if (Array.isArray(result.value)) {
@@ -2518,7 +3140,14 @@ function concat(...parsers) {
 		const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
 		const childExec = {
 			...exec,
-			dependencyRuntime: runtime,
+			dependencyRuntime: runtime
+		};
+		const concatPairs = buildIndexedParserPairs(parsers);
+		const concatState = createAnnotatedArrayStateRecord(stateArray);
+		const preCompleted = await preCompleteAndRegisterDependenciesAsync(concatState, concatPairs, 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);
@@ -2527,8 +3156,8 @@ function concat(...parsers) {
 		let hasDeferred = false;
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
-			const parserState = prepareStateForCompletion(resolvedArray[i], parser);
-			const result = unwrapCompleteResult(await parser.complete(parserState, childExec));
+			const preCompletedResult = preCompleted.get(String(i));
+			const result = preCompletedResult !== void 0 ? unwrapCompleteResult(preCompletedResult) : unwrapCompleteResult(await parser.complete(prepareStateForCompletion(resolvedArray[i], parser), withChildExecPath(phase3Exec, i)));
 			if (!result.success) return result;
 			const baseIndex = results.length;
 			if (Array.isArray(result.value)) {
@@ -2556,7 +3185,7 @@ function concat(...parsers) {
 			} : {}
 		};
 	};
-	return {
+	const concatParser = {
 		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
@@ -2576,31 +3205,25 @@ function concat(...parsers) {
 		suggest(context, prefix) {
 			if (isAsync) return async function* () {
 				const preParsedContext$1 = await preParseSuggestContextAsync(context, parsers);
-				const { context: contextWithRegistry$1, stateArray: stateArray$1 } = buildSuggestRegistry(preParsedContext$1);
+				const { context: contextWithRegistry$1, stateArray: stateArray$1 } = await buildSuggestRegistryAsync(preParsedContext$1, parsers);
 				const suggestions = [];
 				for (let i = 0; i < parsers.length; i++) {
 					const parser = parsers[i];
 					const parserState = stateArray$1 && Array.isArray(stateArray$1) ? stateArray$1[i] : parser.initialState;
-					const parserSuggestions = parser.suggest({
-						...contextWithRegistry$1,
-						state: parserState
-					}, prefix);
+					const parserSuggestions = parser.suggest(withChildContext(contextWithRegistry$1, i, parserState, parser), prefix);
 					if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
 					else suggestions.push(...parserSuggestions);
 				}
 				yield* deduplicateSuggestions(suggestions);
 			}();
 			const preParsedContext = preParseSuggestContext(context, syncParsers);
-			const { context: contextWithRegistry, stateArray } = buildSuggestRegistry(preParsedContext);
+			const { context: contextWithRegistry, stateArray } = buildSuggestRegistry(preParsedContext, syncParsers);
 			return function* () {
 				const suggestions = [];
 				for (let i = 0; i < syncParsers.length; i++) {
 					const parser = syncParsers[i];
 					const parserState = stateArray && Array.isArray(stateArray) ? stateArray[i] : parser.initialState;
-					const parserSuggestions = parser.suggest({
-						...contextWithRegistry,
-						state: parserState
-					}, prefix);
+					const parserSuggestions = parser.suggest(withChildContext(contextWithRegistry, i, parserState, parser), prefix);
 					suggestions.push(...parserSuggestions);
 				}
 				yield* deduplicateSuggestions(suggestions);
@@ -2632,6 +3255,8 @@ function concat(...parsers) {
 			return { fragments: result };
 		}
 	};
+	defineInheritedAnnotationParser(concatParser);
+	return concatParser;
 }
 function group(label, parser, options = {}) {
 	validateLabel(label);
@@ -2646,6 +3271,13 @@ function group(label, parser, options = {}) {
 		initialState: parser.initialState,
 		...fieldParsersKey in parser ? { [fieldParsersKey]: parser[fieldParsersKey] } : {},
 		...typeof parser.shouldDeferCompletion === "function" ? { shouldDeferCompletion: parser.shouldDeferCompletion.bind(parser) } : {},
+		getSuggestRuntimeNodes(state, path) {
+			return parser.getSuggestRuntimeNodes?.(state, path) ?? (parser.dependencyMetadata?.source != null ? [{
+				path,
+				parser,
+				state
+			}] : []);
+		},
 		parse: (context) => parser.parse(context),
 		complete: (state, exec) => parser.complete(state, exec),
 		suggest: (context, prefix) => {
@@ -2788,57 +3420,69 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		const syncDefaultBranch = defaultBranch;
 		if (state.selectedBranch !== void 0) {
 			const branchParser = state.selectedBranch.kind === "default" ? syncDefaultBranch : syncBranches[state.selectedBranch.key];
-			const branchResult = branchParser.parse({
-				...context,
-				state: state.branchState,
-				usage: branchParser.usage
-			});
-			if (branchResult.success) return {
-				success: true,
-				next: {
-					...branchResult.next,
-					state: {
-						...state,
-						branchState: branchResult.next.state
-					}
-				},
-				consumed: branchResult.consumed
-			};
+			const branchResult = branchParser.parse(withChildContext(context, "_branch", state.branchState, branchParser, branchParser.usage));
+			if (branchResult.success) {
+				const mergedExec = mergeChildExec(context.exec, branchResult.next.exec);
+				return {
+					success: true,
+					next: {
+						...branchResult.next,
+						state: {
+							...state,
+							branchState: branchResult.next.state
+						},
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
+					},
+					consumed: branchResult.consumed
+				};
+			}
 			return branchResult;
 		}
-		const discriminatorResult = syncDiscriminator.parse({
-			...context,
-			state: state.discriminatorState
-		});
+		const discriminatorResult = syncDiscriminator.parse({ ...withChildContext(context, "_discriminator", state.discriminatorState) });
 		if (discriminatorResult.success && discriminatorResult.consumed.length > 0) {
-			const completionResult = syncDiscriminator.complete(discriminatorResult.next.state, context.exec);
+			const completionResult = syncDiscriminator.complete(discriminatorResult.next.state, withChildExecPath(context.exec, "_discriminator"));
 			if (completionResult.success) {
 				const value = completionResult.value;
 				const branchParser = syncBranches[value];
 				if (branchParser) {
+					const discriminatorExec = mergeChildExec(context.exec, discriminatorResult.next.exec);
 					const branchParseResult = branchParser.parse({
-						...context,
+						...withChildContext({
+							...context,
+							...discriminatorExec != null ? {
+								exec: discriminatorExec,
+								dependencyRegistry: discriminatorExec.dependencyRegistry
+							} : {}
+						}, "_branch", branchParser.initialState, branchParser, branchParser.usage),
 						buffer: discriminatorResult.next.buffer,
-						optionsTerminated: discriminatorResult.next.optionsTerminated,
-						state: branchParser.initialState,
-						usage: branchParser.usage
+						optionsTerminated: discriminatorResult.next.optionsTerminated
 					});
-					if (branchParseResult.success) return {
-						success: true,
-						next: {
-							...branchParseResult.next,
-							state: {
-								discriminatorState: discriminatorResult.next.state,
-								discriminatorValue: value,
-								selectedBranch: {
-									kind: "branch",
-									key: value
+					if (branchParseResult.success) {
+						const mergedExec = mergeChildExec(discriminatorExec, branchParseResult.next.exec);
+						return {
+							success: true,
+							next: {
+								...branchParseResult.next,
+								state: {
+									discriminatorState: discriminatorResult.next.state,
+									discriminatorValue: value,
+									selectedBranch: {
+										kind: "branch",
+										key: value
+									},
+									branchState: branchParseResult.next.state
 								},
-								branchState: branchParseResult.next.state
-							}
-						},
-						consumed: [...discriminatorResult.consumed, ...branchParseResult.consumed]
-					};
+								...mergedExec != null ? {
+									exec: mergedExec,
+									dependencyRegistry: mergedExec.dependencyRegistry
+								} : {}
+							},
+							consumed: [...discriminatorResult.consumed, ...branchParseResult.consumed]
+						};
+					}
 					return {
 						success: true,
 						next: {
@@ -2851,7 +3495,11 @@ function conditional(discriminator, branches, defaultBranch, options) {
 									key: value
 								},
 								branchState: branchParser.initialState
-							}
+							},
+							...discriminatorExec != null ? {
+								exec: discriminatorExec,
+								dependencyRegistry: discriminatorExec.dependencyRegistry
+							} : {}
 						},
 						consumed: discriminatorResult.consumed
 					};
@@ -2859,23 +3507,26 @@ function conditional(discriminator, branches, defaultBranch, options) {
 			}
 		}
 		if (syncDefaultBranch !== void 0) {
-			const defaultResult = syncDefaultBranch.parse({
-				...context,
-				state: state.branchState ?? syncDefaultBranch.initialState,
-				usage: syncDefaultBranch.usage
-			});
-			if (defaultResult.success && defaultResult.consumed.length > 0) return {
-				success: true,
-				next: {
-					...defaultResult.next,
-					state: {
-						...state,
-						selectedBranch: { kind: "default" },
-						branchState: defaultResult.next.state
-					}
-				},
-				consumed: defaultResult.consumed
-			};
+			const defaultResult = syncDefaultBranch.parse(withChildContext(context, "_branch", state.branchState ?? syncDefaultBranch.initialState, syncDefaultBranch, syncDefaultBranch.usage));
+			if (defaultResult.success && defaultResult.consumed.length > 0) {
+				const mergedExec = mergeChildExec(context.exec, defaultResult.next.exec);
+				return {
+					success: true,
+					next: {
+						...defaultResult.next,
+						state: {
+							...state,
+							selectedBranch: { kind: "default" },
+							branchState: defaultResult.next.state
+						},
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
+					},
+					consumed: defaultResult.consumed
+				};
+			}
 		}
 		return {
 			success: false,
@@ -2887,57 +3538,69 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		const state = context.state ?? initialState;
 		if (state.selectedBranch !== void 0) {
 			const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
-			const branchResult = await branchParser.parse({
-				...context,
-				state: state.branchState,
-				usage: branchParser.usage
-			});
-			if (branchResult.success) return {
-				success: true,
-				next: {
-					...branchResult.next,
-					state: {
-						...state,
-						branchState: branchResult.next.state
-					}
-				},
-				consumed: branchResult.consumed
-			};
+			const branchResult = await branchParser.parse(withChildContext(context, "_branch", state.branchState, branchParser, branchParser.usage));
+			if (branchResult.success) {
+				const mergedExec = mergeChildExec(context.exec, branchResult.next.exec);
+				return {
+					success: true,
+					next: {
+						...branchResult.next,
+						state: {
+							...state,
+							branchState: branchResult.next.state
+						},
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
+					},
+					consumed: branchResult.consumed
+				};
+			}
 			return branchResult;
 		}
-		const discriminatorResult = await discriminator.parse({
-			...context,
-			state: state.discriminatorState
-		});
+		const discriminatorResult = await discriminator.parse({ ...withChildContext(context, "_discriminator", state.discriminatorState) });
 		if (discriminatorResult.success && discriminatorResult.consumed.length > 0) {
-			const completionResult = await discriminator.complete(discriminatorResult.next.state, context.exec);
+			const completionResult = await discriminator.complete(discriminatorResult.next.state, withChildExecPath(context.exec, "_discriminator"));
 			if (completionResult.success) {
 				const value = completionResult.value;
 				const branchParser = branches[value];
 				if (branchParser) {
+					const discriminatorExec = mergeChildExec(context.exec, discriminatorResult.next.exec);
 					const branchParseResult = await branchParser.parse({
-						...context,
+						...withChildContext({
+							...context,
+							...discriminatorExec != null ? {
+								exec: discriminatorExec,
+								dependencyRegistry: discriminatorExec.dependencyRegistry
+							} : {}
+						}, "_branch", branchParser.initialState, branchParser, branchParser.usage),
 						buffer: discriminatorResult.next.buffer,
-						optionsTerminated: discriminatorResult.next.optionsTerminated,
-						state: branchParser.initialState,
-						usage: branchParser.usage
+						optionsTerminated: discriminatorResult.next.optionsTerminated
 					});
-					if (branchParseResult.success) return {
-						success: true,
-						next: {
-							...branchParseResult.next,
-							state: {
-								discriminatorState: discriminatorResult.next.state,
-								discriminatorValue: value,
-								selectedBranch: {
-									kind: "branch",
-									key: value
+					if (branchParseResult.success) {
+						const mergedExec = mergeChildExec(discriminatorExec, branchParseResult.next.exec);
+						return {
+							success: true,
+							next: {
+								...branchParseResult.next,
+								state: {
+									discriminatorState: discriminatorResult.next.state,
+									discriminatorValue: value,
+									selectedBranch: {
+										kind: "branch",
+										key: value
+									},
+									branchState: branchParseResult.next.state
 								},
-								branchState: branchParseResult.next.state
-							}
-						},
-						consumed: [...discriminatorResult.consumed, ...branchParseResult.consumed]
-					};
+								...mergedExec != null ? {
+									exec: mergedExec,
+									dependencyRegistry: mergedExec.dependencyRegistry
+								} : {}
+							},
+							consumed: [...discriminatorResult.consumed, ...branchParseResult.consumed]
+						};
+					}
 					return {
 						success: true,
 						next: {
@@ -2950,7 +3613,11 @@ function conditional(discriminator, branches, defaultBranch, options) {
 									key: value
 								},
 								branchState: branchParser.initialState
-							}
+							},
+							...discriminatorExec != null ? {
+								exec: discriminatorExec,
+								dependencyRegistry: discriminatorExec.dependencyRegistry
+							} : {}
 						},
 						consumed: discriminatorResult.consumed
 					};
@@ -2958,23 +3625,26 @@ function conditional(discriminator, branches, defaultBranch, options) {
 			}
 		}
 		if (defaultBranch !== void 0) {
-			const defaultResult = await defaultBranch.parse({
-				...context,
-				state: state.branchState ?? defaultBranch.initialState,
-				usage: defaultBranch.usage
-			});
-			if (defaultResult.success && defaultResult.consumed.length > 0) return {
-				success: true,
-				next: {
-					...defaultResult.next,
-					state: {
-						...state,
-						selectedBranch: { kind: "default" },
-						branchState: defaultResult.next.state
-					}
-				},
-				consumed: defaultResult.consumed
-			};
+			const defaultResult = await defaultBranch.parse(withChildContext(context, "_branch", state.branchState ?? defaultBranch.initialState, defaultBranch, defaultBranch.usage));
+			if (defaultResult.success && defaultResult.consumed.length > 0) {
+				const mergedExec = mergeChildExec(context.exec, defaultResult.next.exec);
+				return {
+					success: true,
+					next: {
+						...defaultResult.next,
+						state: {
+							...state,
+							selectedBranch: { kind: "default" },
+							branchState: defaultResult.next.state
+						},
+						...mergedExec != null ? {
+							exec: mergedExec,
+							dependencyRegistry: mergedExec.dependencyRegistry
+						} : {}
+					},
+					consumed: defaultResult.consumed
+				};
+			}
 		}
 		return {
 			success: false,
@@ -2989,7 +3659,7 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		if (state.selectedBranch === void 0) {
 			if (syncDefaultBranch !== void 0) {
 				const branchState = state.branchState ?? syncDefaultBranch.initialState;
-				const defaultResult = syncDefaultBranch.complete(branchState, exec);
+				const defaultResult = unwrapCompleteResult(syncDefaultBranch.complete(branchState, withChildExecPath(exec, "_branch")));
 				if (!defaultResult.success) return defaultResult;
 				return {
 					success: true,
@@ -3006,14 +3676,26 @@ function conditional(discriminator, branches, defaultBranch, options) {
 			};
 		}
 		const branchParser = state.selectedBranch.kind === "default" ? syncDefaultBranch : syncBranches[state.selectedBranch.key];
-		const discriminatorCompleteResult = syncDiscriminator.complete(state.discriminatorState, exec);
 		const combinedState = {
 			_discriminator: state.discriminatorState,
 			_branch: state.branchState
 		};
-		const resolvedCombinedState = resolveDeferredParseStates(combinedState);
-		const resolvedBranchState = resolvedCombinedState._branch;
-		const branchResult = branchParser.complete(resolvedBranchState, exec);
+		const runtime = createDependencyRuntimeContext(exec?.dependencyRegistry?.clone());
+		collectExplicitSourceValues(buildRuntimeNodesFromPairs([["_discriminator", discriminator], ["_branch", branchParser]], combinedState, exec?.path), runtime);
+		collectSourcesFromState(combinedState, runtime);
+		const resolvedBranchState = resolveStateWithRuntime(state.branchState, runtime);
+		const completionExec = {
+			...exec ?? {
+				usage: branchParser.usage,
+				path: [],
+				trace: void 0
+			},
+			phase: "complete",
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		};
+		const discriminatorCompleteResult = state.selectedBranch.kind === "default" ? void 0 : syncDiscriminator.complete(state.discriminatorState, withChildExecPath(completionExec, "_discriminator"));
+		const branchResult = unwrapCompleteResult(branchParser.complete(resolvedBranchState, withChildExecPath(completionExec, "_branch")));
 		if (!branchResult.success) {
 			if (state.discriminatorValue !== void 0 && options?.errors?.branchError) return {
 				success: false,
@@ -3023,9 +3705,10 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		}
 		let discriminatorValue;
 		if (state.selectedBranch.kind === "default") discriminatorValue = void 0;
-		else if (isDependencySourceState(discriminatorCompleteResult)) discriminatorValue = discriminatorCompleteResult.result.success ? discriminatorCompleteResult.result.value : state.selectedBranch.key;
-		else if (discriminatorCompleteResult.success) discriminatorValue = discriminatorCompleteResult.value;
-		else discriminatorValue = state.selectedBranch.key;
+		else {
+			const completedDiscriminator = unwrapCompleteResult(discriminatorCompleteResult);
+			discriminatorValue = completedDiscriminator.success ? completedDiscriminator.value : state.selectedBranch.key;
+		}
 		return {
 			success: true,
 			value: [discriminatorValue, branchResult.value],
@@ -3039,7 +3722,7 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		if (state.selectedBranch === void 0) {
 			if (defaultBranch !== void 0) {
 				const branchState = state.branchState ?? defaultBranch.initialState;
-				const defaultResult = await defaultBranch.complete(branchState, exec);
+				const defaultResult = unwrapCompleteResult(await defaultBranch.complete(branchState, withChildExecPath(exec, "_branch")));
 				if (!defaultResult.success) return defaultResult;
 				return {
 					success: true,
@@ -3056,14 +3739,26 @@ function conditional(discriminator, branches, defaultBranch, options) {
 			};
 		}
 		const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
-		const discriminatorCompleteResult = await discriminator.complete(state.discriminatorState, exec);
 		const combinedState = {
 			_discriminator: state.discriminatorState,
 			_branch: state.branchState
 		};
-		const resolvedCombinedState = await resolveDeferredParseStatesAsync(combinedState);
-		const resolvedBranchState = resolvedCombinedState._branch;
-		const branchResult = await branchParser.complete(resolvedBranchState, exec);
+		const runtime = createDependencyRuntimeContext(exec?.dependencyRegistry?.clone());
+		await collectExplicitSourceValuesAsync(buildRuntimeNodesFromPairs([["_discriminator", discriminator], ["_branch", branchParser]], combinedState, exec?.path), runtime);
+		collectSourcesFromState(combinedState, runtime);
+		const resolvedBranchState = await resolveStateWithRuntimeAsync(state.branchState, runtime);
+		const completionExec = {
+			...exec ?? {
+				usage: branchParser.usage,
+				path: [],
+				trace: void 0
+			},
+			phase: "complete",
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		};
+		const discriminatorCompleteResult = state.selectedBranch.kind === "default" ? void 0 : await discriminator.complete(state.discriminatorState, withChildExecPath(completionExec, "_discriminator"));
+		const branchResult = unwrapCompleteResult(await branchParser.complete(resolvedBranchState, withChildExecPath(completionExec, "_branch")));
 		if (!branchResult.success) {
 			if (state.discriminatorValue !== void 0 && options?.errors?.branchError) return {
 				success: false,
@@ -3073,9 +3768,10 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		}
 		let discriminatorValue;
 		if (state.selectedBranch.kind === "default") discriminatorValue = void 0;
-		else if (isDependencySourceState(discriminatorCompleteResult)) discriminatorValue = discriminatorCompleteResult.result.success ? discriminatorCompleteResult.result.value : state.selectedBranch.key;
-		else if (discriminatorCompleteResult.success) discriminatorValue = discriminatorCompleteResult.value;
-		else discriminatorValue = state.selectedBranch.key;
+		else {
+			const completedDiscriminator = unwrapCompleteResult(discriminatorCompleteResult);
+			discriminatorValue = completedDiscriminator.success ? completedDiscriminator.value : state.selectedBranch.key;
+		}
 		return {
 			success: true,
 			value: [discriminatorValue, branchResult.value],
@@ -3091,42 +3787,92 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		const syncBranches = branches;
 		const syncDefaultBranch = defaultBranch;
 		if (state.selectedBranch === void 0) {
-			yield* syncDiscriminator.suggest({
-				...context,
-				state: state.discriminatorState
-			}, prefix);
-			if (syncDefaultBranch !== void 0) yield* syncDefaultBranch.suggest({
+			const runtime = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
+			collectExplicitSourceValues(buildRuntimeNodesFromPairs(syncDefaultBranch == null ? [["_discriminator", discriminator]] : [["_discriminator", discriminator], ["_branch", syncDefaultBranch]], {
+				_discriminator: state.discriminatorState,
+				_branch: state.branchState
+			}, context.exec?.path), runtime);
+			collectSourcesFromState({
+				_discriminator: state.discriminatorState,
+				_branch: state.branchState
+			}, runtime);
+			const suggestContext = {
 				...context,
-				state: state.branchState ?? syncDefaultBranch.initialState
-			}, prefix);
+				dependencyRegistry: runtime.registry,
+				...context.exec != null ? { exec: {
+					...context.exec,
+					dependencyRuntime: runtime,
+					dependencyRegistry: runtime.registry
+				} } : {}
+			};
+			yield* syncDiscriminator.suggest(withChildContext(suggestContext, "_discriminator", state.discriminatorState), prefix);
+			if (syncDefaultBranch !== void 0) yield* syncDefaultBranch.suggest(withChildContext(suggestContext, "_branch", state.branchState ?? syncDefaultBranch.initialState), prefix);
 		} else {
 			const branchParser = state.selectedBranch.kind === "default" ? syncDefaultBranch : syncBranches[state.selectedBranch.key];
-			yield* branchParser.suggest({
+			const runtime = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
+			const combinedState = {
+				_discriminator: state.discriminatorState,
+				_branch: state.branchState
+			};
+			collectExplicitSourceValues(buildRuntimeNodesFromPairs([["_discriminator", discriminator], ["_branch", branchParser]], combinedState, context.exec?.path), runtime);
+			collectSourcesFromState(combinedState, runtime);
+			const suggestContext = {
 				...context,
-				state: state.branchState
-			}, prefix);
+				dependencyRegistry: runtime.registry,
+				...context.exec != null ? { exec: {
+					...context.exec,
+					dependencyRuntime: runtime,
+					dependencyRegistry: runtime.registry
+				} } : {}
+			};
+			yield* branchParser.suggest(withChildContext(suggestContext, "_branch", state.branchState), prefix);
 		}
 	}
 	async function* suggestAsync(context, prefix) {
 		const state = context.state ?? initialState;
 		if (state.selectedBranch === void 0) {
-			yield* discriminator.suggest({
-				...context,
-				state: state.discriminatorState
-			}, prefix);
-			if (defaultBranch !== void 0) yield* defaultBranch.suggest({
+			const runtime = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
+			await collectExplicitSourceValuesAsync(buildRuntimeNodesFromPairs(defaultBranch == null ? [["_discriminator", discriminator]] : [["_discriminator", discriminator], ["_branch", defaultBranch]], {
+				_discriminator: state.discriminatorState,
+				_branch: state.branchState
+			}, context.exec?.path), runtime);
+			collectSourcesFromState({
+				_discriminator: state.discriminatorState,
+				_branch: state.branchState
+			}, runtime);
+			const suggestContext = {
 				...context,
-				state: state.branchState ?? defaultBranch.initialState
-			}, prefix);
+				dependencyRegistry: runtime.registry,
+				...context.exec != null ? { exec: {
+					...context.exec,
+					dependencyRuntime: runtime,
+					dependencyRegistry: runtime.registry
+				} } : {}
+			};
+			yield* discriminator.suggest(withChildContext(suggestContext, "_discriminator", state.discriminatorState), prefix);
+			if (defaultBranch !== void 0) yield* defaultBranch.suggest(withChildContext(suggestContext, "_branch", state.branchState ?? defaultBranch.initialState), prefix);
 		} else {
 			const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
-			yield* branchParser.suggest({
+			const runtime = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
+			const combinedState = {
+				_discriminator: state.discriminatorState,
+				_branch: state.branchState
+			};
+			await collectExplicitSourceValuesAsync(buildRuntimeNodesFromPairs([["_discriminator", discriminator], ["_branch", branchParser]], combinedState, context.exec?.path), runtime);
+			collectSourcesFromState(combinedState, runtime);
+			const suggestContext = {
 				...context,
-				state: state.branchState
-			}, prefix);
+				dependencyRegistry: runtime.registry,
+				...context.exec != null ? { exec: {
+					...context.exec,
+					dependencyRuntime: runtime,
+					dependencyRegistry: runtime.registry
+				} } : {}
+			};
+			yield* branchParser.suggest(withChildContext(suggestContext, "_branch", state.branchState), prefix);
 		}
 	}
-	return {
+	const conditionalParser = {
 		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
@@ -3174,6 +3920,8 @@ function conditional(discriminator, branches, defaultBranch, options) {
 			return { fragments };
 		}
 	};
+	defineInheritedAnnotationParser(conditionalParser);
+	return conditionalParser;
 }
 
 //#endregion