@optique/core 1.0.0-dev.1602 → 1.0.0-dev.1611

package/dist/constructs.js

@@ -1,6 +1,7 @@
 import { 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 { validateLabel } from "./validate.js";
 import { extractArgumentMetavars, extractCommandNames, extractOptionNames, isDocHidden, mergeHidden } from "./usage.js";
@@ -55,6 +56,34 @@ const inheritParentAnnotationsKey = Symbol.for("@optique/core/inheritParentAnnot
 */
 const fieldParsersKey = Symbol("fieldParsers");
 /**
+* Extracts the actual {@link ValueParserResult} from a `complete()` return
+* value, which may be a plain result or a `DependencySourceState` wrapper
+* from the old protocol.  This bridge helper allows the new runtime path
+* to consume results from parsers that still return `DependencySourceState`.
+* @internal
+*/
+function unwrapCompleteResult(result) {
+	if (isDependencySourceState(result)) return result.result;
+	return result;
+}
+/**
+* Prepares a field state for completion by wrapping `undefined` state
+* with the parser's initial pending dependency state when needed.
+*
+* In the old protocol, when a parser has a `PendingDependencySourceState`
+* as its initial state and the field state is `undefined` (option not
+* provided), the construct wraps it as `[initialState]` so that
+* `withDefault().complete()` can detect the pending dependency and
+* return a `DependencySourceState` with the default value.
+* @internal
+*/
+function prepareStateForCompletion(fieldState, parser) {
+	if (fieldState !== void 0) return fieldState;
+	if (isPendingDependencySourceState(parser.initialState)) return [parser.initialState];
+	if (isWrappedDependencySource(parser)) return [parser[wrappedDependencySourceMarker]];
+	return fieldState;
+}
+/**
 * 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
@@ -689,12 +718,14 @@ function longestMatch(...args) {
 * @internal
 */
 function* suggestObjectSync(context, prefix, parserPairs) {
-	const registry = context.dependencyRegistry ? context.dependencyRegistry.clone() : new DependencyRegistry();
-	if (context.state && typeof context.state === "object") collectDependencies(context.state, registry);
-	completeDependencySourceDefaults(context, parserPairs, registry, context.exec);
+	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);
+	completeDependencySourceDefaults(context, parserPairs, runtime.registry, context.exec);
 	const contextWithRegistry = {
 		...context,
-		dependencyRegistry: registry
+		dependencyRegistry: runtime.registry
 	};
 	if (context.buffer.length > 0) {
 		const lastToken = context.buffer[context.buffer.length - 1];
@@ -723,12 +754,14 @@ function* suggestObjectSync(context, prefix, parserPairs) {
 * @internal
 */
 async function* suggestObjectAsync(context, prefix, parserPairs) {
-	const registry = context.dependencyRegistry ? context.dependencyRegistry.clone() : new DependencyRegistry();
-	if (context.state && typeof context.state === "object") collectDependencies(context.state, registry);
-	await completeDependencySourceDefaultsAsync(context, parserPairs, registry, context.exec);
+	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 contextWithRegistry = {
 		...context,
-		dependencyRegistry: registry
+		dependencyRegistry: runtime.registry
 	};
 	if (context.buffer.length > 0) {
 		const lastToken = context.buffer[context.buffer.length - 1];
@@ -846,6 +879,31 @@ async function completeDependencySourceDefaultsAsync(context, parserPairs, regis
 * mappings from its child `object()` (or nested `merge()`) parsers.
 * @internal
 */
+/**
+* Removes entries for duplicate field names from a pre-completed results
+* map.  When a child construct's field-parser pairs contain the same field
+* name more than once (e.g., inner merges with overlapping output keys),
+* the flat map collapses branch-specific results.  This function strips
+* only the ambiguous entries, preserving cached results for unique fields.
+*
+* Returns `undefined` if the filtered map is empty (no cacheable fields).
+*
+* @see https://github.com/dahlia/optique/issues/762
+* @internal
+*/
+function filterDuplicateKeys(preCompleted, pairs) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const [field] of pairs) counts.set(field, (counts.get(field) ?? 0) + 1);
+	let hasDuplicates = false;
+	for (const count of counts.values()) if (count > 1) {
+		hasDuplicates = true;
+		break;
+	}
+	if (!hasDuplicates) return preCompleted;
+	const filtered = /* @__PURE__ */ new Map();
+	for (const [field, value] of preCompleted) if ((counts.get(field) ?? 0) <= 1) filtered.set(field, value);
+	return filtered.size > 0 ? filtered : void 0;
+}
 function collectChildFieldParsers(parsers) {
 	const pairs = [];
 	for (const parser of parsers) if (fieldParsersKey in parser) pairs.push(...parser[fieldParsersKey]);
@@ -858,45 +916,85 @@ function collectChildFieldParsers(parsers) {
 * PendingDependencySourceState in arrays and wrappedDependencySourceMarker.
 *
 * The original state is NOT modified; only the registry is populated.
+*
+* Used by the new dependency runtime path as an old-protocol bridge:
+* not all wrappers (e.g., `bindConfig`, `bindEnv`) compose
+* `dependencyMetadata` yet, so metadata-based source collection alone
+* cannot register all dependency values.  This function fills the gap
+* by inspecting old-protocol markers on the parsers.
 * @internal
 */
 function preCompleteAndRegisterDependencies(state, fieldParserPairs, registry, exec) {
+	const preCompleted = /* @__PURE__ */ new Map();
+	const parentResults = exec?.preCompletedByParser;
 	for (const [field, fieldParser] of fieldParserPairs) {
+		const cached = parentResults?.get(field);
+		if (cached !== void 0) {
+			preCompleted.set(field, cached);
+			registerCompletedDependency(cached, registry);
+			continue;
+		}
 		const fieldState = state[field];
-		let completed;
-		if (Array.isArray(fieldState) && fieldState.length === 1 && isPendingDependencySourceState(fieldState[0])) completed = fieldParser.complete(fieldState, exec);
-		else if (fieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState)) completed = fieldParser.complete([fieldParser.initialState], exec);
-		else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
+		if (Array.isArray(fieldState) && fieldState.length === 1 && isPendingDependencySourceState(fieldState[0])) {
+			const completed = fieldParser.complete(fieldState, exec);
+			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);
+			preCompleted.set(field, completed);
+			if (isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
+		} else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
 			const pendingState = fieldParser[wrappedDependencySourceMarker];
-			completed = fieldParser.complete([pendingState], exec);
+			const completed = fieldParser.complete([pendingState], exec);
+			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);
-			completed = fieldParser.complete(annotatedFieldState, exec);
-		} else continue;
-		const depState = wrapAsDependencySourceState(completed, fieldParser);
-		if (depState) registerCompletedDependency(depState, registry);
+			const completed = fieldParser.complete(annotatedFieldState, exec);
+			preCompleted.set(field, completed);
+			const depState = wrapAsDependencySourceState(completed, fieldParser);
+			if (depState) registerCompletedDependency(depState, registry);
+		}
 	}
+	return preCompleted;
 }
 /**
 * Async version of {@link preCompleteAndRegisterDependencies}.
 * @internal
 */
 async function preCompleteAndRegisterDependenciesAsync(state, fieldParserPairs, registry, exec) {
+	const preCompleted = /* @__PURE__ */ new Map();
+	const parentResults = exec?.preCompletedByParser;
 	for (const [field, fieldParser] of fieldParserPairs) {
+		const cached = parentResults?.get(field);
+		if (cached !== void 0) {
+			preCompleted.set(field, cached);
+			registerCompletedDependency(cached, registry);
+			continue;
+		}
 		const fieldState = state[field];
-		let completed;
-		if (Array.isArray(fieldState) && fieldState.length === 1 && isPendingDependencySourceState(fieldState[0])) completed = await fieldParser.complete(fieldState, exec);
-		else if (fieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState)) completed = await fieldParser.complete([fieldParser.initialState], exec);
-		else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
+		if (Array.isArray(fieldState) && fieldState.length === 1 && isPendingDependencySourceState(fieldState[0])) {
+			const completed = await fieldParser.complete(fieldState, exec);
+			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);
+			preCompleted.set(field, completed);
+			if (isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
+		} else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
 			const pendingState = fieldParser[wrappedDependencySourceMarker];
-			completed = await fieldParser.complete([pendingState], exec);
+			const completed = await fieldParser.complete([pendingState], exec);
+			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);
-			completed = await fieldParser.complete(annotatedFieldState, exec);
-		} else continue;
-		const depState = wrapAsDependencySourceState(completed, fieldParser);
-		if (depState) registerCompletedDependency(depState, registry);
+			const completed = await fieldParser.complete(annotatedFieldState, exec);
+			preCompleted.set(field, completed);
+			const depState = wrapAsDependencySourceState(completed, fieldParser);
+			if (depState) registerCompletedDependency(depState, registry);
+		}
 	}
+	return preCompleted;
 }
 /**
 * Recursively collects dependency values from DependencySourceState objects
@@ -1240,62 +1338,38 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		},
 		complete(state, exec) {
 			return dispatchByMode(combinedMode, () => {
-				const preCompletedState = {};
-				const preCompletedKeys = /* @__PURE__ */ new Set();
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = {
+					...exec,
+					dependencyRuntime: runtime
+				};
+				const typedParserPairs = parserPairs;
+				const preCompleted = preCompleteAndRegisterDependencies(state, typedParserPairs, runtime.registry, childExec);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
 				const getFieldState = createFieldStateGetter(state);
+				const annotatedState = {};
 				for (const field of parserKeys) {
 					const fieldKey = field;
-					const fieldState = state[fieldKey];
 					const fieldParser = parsers[field];
-					if (Array.isArray(fieldState) && fieldState.length === 1 && isPendingDependencySourceState(fieldState[0])) {
-						const completed = fieldParser.complete(fieldState, exec);
-						preCompletedState[fieldKey] = completed;
-						preCompletedKeys.add(fieldKey);
-					} else if (fieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState)) {
-						const completed = fieldParser.complete([fieldParser.initialState], exec);
-						preCompletedState[fieldKey] = completed;
-						preCompletedKeys.add(fieldKey);
-					} else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
-						const pendingState = fieldParser[wrappedDependencySourceMarker];
-						const completed = fieldParser.complete([pendingState], exec);
-						if (isDependencySourceState(completed)) {
-							preCompletedState[fieldKey] = completed;
-							preCompletedKeys.add(fieldKey);
-						} else preCompletedState[fieldKey] = fieldState;
-					} else if (fieldState != null && !Array.isArray(fieldState) && !isDependencySourceState(fieldState) && (isWrappedDependencySource(fieldParser) || isPendingDependencySourceState(fieldParser.initialState))) {
-						const annotatedFieldState = getFieldState(field, fieldParser);
-						const completed = fieldParser.complete(annotatedFieldState, exec);
-						const depState = wrapAsDependencySourceState(completed, fieldParser);
-						if (depState) {
-							preCompletedState[fieldKey] = depState;
-							preCompletedKeys.add(fieldKey);
-						} else preCompletedState[fieldKey] = annotatedFieldState;
-					} else preCompletedState[fieldKey] = getFieldState(field, fieldParser);
+					annotatedState[fieldKey] = getFieldState(field, fieldParser);
 				}
-				const resolvedState = resolveDeferredParseStates(preCompletedState);
+				const resolvedFieldStates = resolveStateWithRuntime(annotatedState, runtime);
 				const result = {};
 				const deferredKeys = /* @__PURE__ */ new Map();
 				let hasDeferred = false;
-				const getCompletionFieldState = createFieldStateGetter(state);
 				for (const field of parserKeys) {
 					const fieldKey = field;
-					const fieldResolvedState = resolvedState[fieldKey];
 					const fieldParser = parsers[field];
-					if (isDependencySourceState(fieldResolvedState) && preCompletedKeys.has(fieldKey)) {
-						const depResult = fieldResolvedState.result;
-						if (depResult.success) {
-							result[fieldKey] = depResult.value;
-							if (depResult.deferred) if (depResult.deferredKeys) deferredKeys.set(fieldKey, depResult.deferredKeys);
-							else if (depResult.value == null || typeof depResult.value !== "object") deferredKeys.set(fieldKey, null);
-							else hasDeferred = true;
-						} else return {
-							success: false,
-							error: depResult.error
-						};
-						continue;
+					let valueResult;
+					const preCompletedResult = preCompleted.get(fieldKey);
+					if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
+					else {
+						const fieldState = resolvedFieldStates[fieldKey];
+						valueResult = unwrapCompleteResult(fieldParser.complete(fieldState, phase3Exec));
 					}
-					const completionState = fieldResolvedState === void 0 ? getCompletionFieldState(field, fieldParser) : fieldResolvedState;
-					const valueResult = fieldParser.complete(completionState, exec);
 					if (valueResult.success) {
 						result[fieldKey] = valueResult.value;
 						if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(fieldKey, valueResult.deferredKeys);
@@ -1316,62 +1390,38 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 					} : {}
 				};
 			}, async () => {
-				const preCompletedState = {};
-				const preCompletedKeys = /* @__PURE__ */ new Set();
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = {
+					...exec,
+					dependencyRuntime: runtime
+				};
+				const asyncParserPairs = parserPairs;
+				const preCompleted = await preCompleteAndRegisterDependenciesAsync(state, asyncParserPairs, runtime.registry, childExec);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
 				const getFieldState = createFieldStateGetter(state);
+				const annotatedState = {};
 				for (const field of parserKeys) {
 					const fieldKey = field;
-					const fieldState = state[fieldKey];
 					const fieldParser = parsers[field];
-					if (Array.isArray(fieldState) && fieldState.length === 1 && isPendingDependencySourceState(fieldState[0])) {
-						const completed = await fieldParser.complete(fieldState, exec);
-						preCompletedState[fieldKey] = completed;
-						preCompletedKeys.add(fieldKey);
-					} else if (fieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState)) {
-						const completed = await fieldParser.complete([fieldParser.initialState], exec);
-						preCompletedState[fieldKey] = completed;
-						preCompletedKeys.add(fieldKey);
-					} else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
-						const pendingState = fieldParser[wrappedDependencySourceMarker];
-						const completed = await fieldParser.complete([pendingState], exec);
-						if (isDependencySourceState(completed)) {
-							preCompletedState[fieldKey] = completed;
-							preCompletedKeys.add(fieldKey);
-						} else preCompletedState[fieldKey] = fieldState;
-					} else if (fieldState != null && !Array.isArray(fieldState) && !isDependencySourceState(fieldState) && (isWrappedDependencySource(fieldParser) || isPendingDependencySourceState(fieldParser.initialState))) {
-						const annotatedFieldState = getFieldState(field, fieldParser);
-						const completed = await fieldParser.complete(annotatedFieldState, exec);
-						const depState = wrapAsDependencySourceState(completed, fieldParser);
-						if (depState) {
-							preCompletedState[fieldKey] = depState;
-							preCompletedKeys.add(fieldKey);
-						} else preCompletedState[fieldKey] = annotatedFieldState;
-					} else preCompletedState[fieldKey] = getFieldState(field, fieldParser);
+					annotatedState[fieldKey] = getFieldState(field, fieldParser);
 				}
-				const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
+				const resolvedFieldStates = await resolveStateWithRuntimeAsync(annotatedState, runtime);
 				const result = {};
 				const deferredKeys = /* @__PURE__ */ new Map();
 				let hasDeferred = false;
-				const getCompletionFieldState = createFieldStateGetter(state);
 				for (const field of parserKeys) {
 					const fieldKey = field;
-					const fieldResolvedState = resolvedState[fieldKey];
 					const fieldParser = parsers[field];
-					if (isDependencySourceState(fieldResolvedState) && preCompletedKeys.has(fieldKey)) {
-						const depResult = fieldResolvedState.result;
-						if (depResult.success) {
-							result[fieldKey] = depResult.value;
-							if (depResult.deferred) if (depResult.deferredKeys) deferredKeys.set(fieldKey, depResult.deferredKeys);
-							else if (depResult.value == null || typeof depResult.value !== "object") deferredKeys.set(fieldKey, null);
-							else hasDeferred = true;
-						} else return {
-							success: false,
-							error: depResult.error
-						};
-						continue;
+					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 completionState = fieldResolvedState === void 0 ? getCompletionFieldState(field, fieldParser) : fieldResolvedState;
-					const valueResult = await fieldParser.complete(completionState, exec);
 					if (valueResult.success) {
 						result[fieldKey] = valueResult.value;
 						if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(fieldKey, valueResult.deferredKeys);
@@ -1635,48 +1685,31 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		complete(state, exec) {
 			return dispatchByMode(combinedMode, () => {
 				const stateArray = state;
-				const preCompletedState = [];
-				for (let i = 0; i < syncParsers.length; i++) {
-					const elementState = stateArray[i];
-					const elementParser = syncParsers[i];
-					if (Array.isArray(elementState) && elementState.length === 1 && isPendingDependencySourceState(elementState[0])) {
-						const completed = elementParser.complete(elementState, exec);
-						preCompletedState[i] = completed;
-					} else if (elementState === void 0 && isPendingDependencySourceState(elementParser.initialState)) {
-						const completed = elementParser.complete([elementParser.initialState], exec);
-						preCompletedState[i] = completed;
-					} else if (elementState === void 0 && isWrappedDependencySource(elementParser)) {
-						const pendingState = elementParser[wrappedDependencySourceMarker];
-						const completed = elementParser.complete([pendingState], exec);
-						preCompletedState[i] = completed;
-					} else preCompletedState[i] = elementState;
-				}
-				const resolvedState = resolveDeferredParseStates(preCompletedState);
-				const resolvedArray = resolvedState;
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = {
+					...exec,
+					dependencyRuntime: runtime
+				};
+				const tuplePairs = syncParsers.map((p, i) => [String(i), p]);
+				const tupleState = Object.fromEntries(stateArray.map((s, i) => [String(i), s]));
+				const preCompleted = preCompleteAndRegisterDependencies(tupleState, tuplePairs, runtime.registry, childExec);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const resolvedArray = resolveStateWithRuntime(stateArray, runtime);
 				const result = [];
 				const deferredKeys = /* @__PURE__ */ new Map();
 				let hasDeferred = false;
 				for (let i = 0; i < syncParsers.length; i++) {
-					const elementResolvedState = resolvedArray[i];
 					const elementParser = syncParsers[i];
-					const originalElementState = stateArray[i];
-					const wasPreCompletedCase1 = Array.isArray(originalElementState) && originalElementState.length === 1 && isPendingDependencySourceState(originalElementState[0]);
-					const wasPreCompletedCase2 = originalElementState === void 0 && isPendingDependencySourceState(elementParser.initialState);
-					const wasPreCompletedCase3 = originalElementState === void 0 && isWrappedDependencySource(elementParser);
-					if (isDependencySourceState(elementResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
-						const depResult = elementResolvedState.result;
-						if (depResult.success) {
-							result[i] = depResult.value;
-							if (depResult.deferred) if (depResult.deferredKeys) deferredKeys.set(i, depResult.deferredKeys);
-							else if (depResult.value == null || typeof depResult.value !== "object") deferredKeys.set(i, null);
-							else hasDeferred = true;
-						} else return {
-							success: false,
-							error: depResult.error
-						};
-						continue;
+					let valueResult;
+					const preCompletedResult = preCompleted.get(String(i));
+					if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
+					else {
+						const elementState = prepareStateForCompletion(resolvedArray[i], elementParser);
+						valueResult = unwrapCompleteResult(elementParser.complete(elementState, phase3Exec));
 					}
-					const valueResult = elementParser.complete(elementResolvedState, exec);
 					if (valueResult.success) {
 						result[i] = valueResult.value;
 						if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(i, valueResult.deferredKeys);
@@ -1698,48 +1731,31 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				};
 			}, async () => {
 				const stateArray = state;
-				const preCompletedState = [];
-				for (let i = 0; i < parsers.length; i++) {
-					const elementState = stateArray[i];
-					const elementParser = parsers[i];
-					if (Array.isArray(elementState) && elementState.length === 1 && isPendingDependencySourceState(elementState[0])) {
-						const completed = await elementParser.complete(elementState, exec);
-						preCompletedState[i] = completed;
-					} else if (elementState === void 0 && isPendingDependencySourceState(elementParser.initialState)) {
-						const completed = await elementParser.complete([elementParser.initialState], exec);
-						preCompletedState[i] = completed;
-					} else if (elementState === void 0 && isWrappedDependencySource(elementParser)) {
-						const pendingState = elementParser[wrappedDependencySourceMarker];
-						const completed = await elementParser.complete([pendingState], exec);
-						preCompletedState[i] = completed;
-					} else preCompletedState[i] = elementState;
-				}
-				const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
-				const resolvedArray = resolvedState;
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = {
+					...exec,
+					dependencyRuntime: runtime
+				};
+				const tuplePairs = parsers.map((p, i) => [String(i), p]);
+				const tupleState = Object.fromEntries(stateArray.map((s, i) => [String(i), s]));
+				const preCompleted = await preCompleteAndRegisterDependenciesAsync(tupleState, tuplePairs, runtime.registry, childExec);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const resolvedArray = await resolveStateWithRuntimeAsync(stateArray, runtime);
 				const result = [];
 				const deferredKeys = /* @__PURE__ */ new Map();
 				let hasDeferred = false;
 				for (let i = 0; i < parsers.length; i++) {
-					const elementResolvedState = resolvedArray[i];
 					const elementParser = parsers[i];
-					const originalElementState = stateArray[i];
-					const wasPreCompletedCase1 = Array.isArray(originalElementState) && originalElementState.length === 1 && isPendingDependencySourceState(originalElementState[0]);
-					const wasPreCompletedCase2 = originalElementState === void 0 && isPendingDependencySourceState(elementParser.initialState);
-					const wasPreCompletedCase3 = originalElementState === void 0 && isWrappedDependencySource(elementParser);
-					if (isDependencySourceState(elementResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
-						const depResult = elementResolvedState.result;
-						if (depResult.success) {
-							result[i] = depResult.value;
-							if (depResult.deferred) if (depResult.deferredKeys) deferredKeys.set(i, depResult.deferredKeys);
-							else if (depResult.value == null || typeof depResult.value !== "object") deferredKeys.set(i, null);
-							else hasDeferred = true;
-						} else return {
-							success: false,
-							error: depResult.error
-						};
-						continue;
+					let valueResult;
+					const preCompletedResult = preCompleted.get(String(i));
+					if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
+					else {
+						const elementState = prepareStateForCompletion(resolvedArray[i], elementParser);
+						valueResult = unwrapCompleteResult(await elementParser.complete(elementState, phase3Exec));
 					}
-					const valueResult = await elementParser.complete(elementResolvedState, exec);
 					if (valueResult.success) {
 						result[i] = valueResult.value;
 						if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(i, valueResult.deferredKeys);
@@ -1999,20 +2015,35 @@ function merge(...args) {
 				return parser.initialState;
 			};
 			if (!isAsync) {
-				const childFieldPairs = collectChildFieldParsers(syncParsers);
-				const registry = new DependencyRegistry();
-				preCompleteAndRegisterDependencies(state, childFieldPairs, registry, exec);
-				const resolvedState = resolveDeferredParseStates(state, registry);
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = {
+					...exec,
+					dependencyRuntime: runtime
+				};
+				const perChildCache = syncParsers.map((parser) => {
+					if (fieldParsersKey in parser) {
+						const pairs = parser[fieldParsersKey];
+						const preCompleted = preCompleteAndRegisterDependencies(state, pairs, runtime.registry, childExec);
+						return filterDuplicateKeys(preCompleted, pairs);
+					}
+					return void 0;
+				});
+				const resolvedState = resolveStateWithRuntime(state, runtime);
 				const object$1 = {};
 				const deferredKeys = /* @__PURE__ */ new Map();
 				let hasDeferred = false;
 				for (let i = 0; i < syncParsers.length; i++) {
 					const parser = syncParsers[i];
 					const parserState = extractCompleteState(parser, resolvedState, i);
-					const result = parser.complete(parserState, exec);
+					const cache = perChildCache[i];
+					const result = unwrapCompleteResult(parser.complete(parserState, {
+						...childExec,
+						preCompletedByParser: cache
+					}));
 					if (!result.success) return result;
-					for (const field in result.value) {
-						object$1[field] = result.value[field];
+					const resultValue = result.value;
+					for (const field in resultValue) {
+						object$1[field] = resultValue[field];
 						if (deferredKeys.has(field) && !(result.deferred && result.deferredKeys?.has(field))) deferredKeys.delete(field);
 					}
 					if (result.deferred && result.deferredKeys) for (const [key, value] of result.deferredKeys) deferredKeys.set(key, value);
@@ -2029,20 +2060,33 @@ function merge(...args) {
 				};
 			}
 			return (async () => {
-				const childFieldPairs = collectChildFieldParsers(parsers);
-				const registry = new DependencyRegistry();
-				await preCompleteAndRegisterDependenciesAsync(state, childFieldPairs, registry, exec);
-				const resolvedState = await resolveDeferredParseStatesAsync(state, registry);
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = {
+					...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 resolvedState = await resolveStateWithRuntimeAsync(state, runtime);
 				const object$1 = {};
 				const deferredKeys = /* @__PURE__ */ new Map();
 				let hasDeferred = false;
 				for (let i = 0; i < parsers.length; i++) {
 					const parser = parsers[i];
 					const parserState = extractCompleteState(parser, resolvedState, i);
-					const result = await parser.complete(parserState, exec);
+					const asyncCache = perChildCache[i];
+					const result = unwrapCompleteResult(await parser.complete(parserState, {
+						...childExec,
+						preCompletedByParser: asyncCache
+					}));
 					if (!result.success) return result;
-					for (const field in result.value) {
-						object$1[field] = result.value[field];
+					const resultValue = result.value;
+					for (const field in resultValue) {
+						object$1[field] = resultValue[field];
 						if (deferredKeys.has(field) && !(result.deferred && result.deferredKeys?.has(field))) deferredKeys.delete(field);
 					}
 					if (result.deferred && result.deferredKeys) for (const [key, value] of result.deferredKeys) deferredKeys.set(key, value);
@@ -2077,15 +2121,13 @@ function merge(...args) {
 				return p.initialState;
 			};
 			if (isAsync) return async function* () {
-				const registry$1 = context.dependencyRegistry ? context.dependencyRegistry.clone() : new DependencyRegistry();
+				const runtime$1 = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
 				const childFieldPairs$1 = collectChildFieldParsers(parsers);
-				if (context.state && typeof context.state === "object") {
-					await preCompleteAndRegisterDependenciesAsync(context.state, childFieldPairs$1, registry$1, context.exec);
-					collectDependencies(context.state, registry$1);
-				} else await completeDependencySourceDefaultsAsync(context, childFieldPairs$1, registry$1, context.exec);
+				if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime$1);
+				await completeDependencySourceDefaultsAsync(context, childFieldPairs$1, runtime$1.registry, context.exec);
 				const contextWithRegistry$1 = {
 					...context,
-					dependencyRegistry: registry$1
+					dependencyRegistry: runtime$1.registry
 				};
 				const suggestions = [];
 				for (let i = 0; i < parsers.length; i++) {
@@ -2100,15 +2142,13 @@ function merge(...args) {
 				}
 				yield* deduplicateSuggestions(suggestions);
 			}();
-			const registry = context.dependencyRegistry ? context.dependencyRegistry.clone() : new DependencyRegistry();
+			const runtime = createDependencyRuntimeContext(context.dependencyRegistry?.clone());
 			const childFieldPairs = collectChildFieldParsers(syncParsers);
-			if (context.state && typeof context.state === "object") {
-				preCompleteAndRegisterDependencies(context.state, childFieldPairs, registry, context.exec);
-				collectDependencies(context.state, registry);
-			} else completeDependencySourceDefaults(context, childFieldPairs, registry, context.exec);
+			if (context.state && typeof context.state === "object") collectSourcesFromState(context.state, runtime);
+			completeDependencySourceDefaults(context, childFieldPairs, runtime.registry, context.exec);
 			const contextWithRegistry = {
 				...context,
-				dependencyRegistry: registry
+				dependencyRegistry: runtime.registry
 			};
 			return function* () {
 				const suggestions = [];
@@ -2195,12 +2235,12 @@ function merge(...args) {
 */
 function buildSuggestRegistry(preParsedContext) {
 	const stateArray = preParsedContext.state;
-	const registry = preParsedContext.dependencyRegistry ? preParsedContext.dependencyRegistry.clone() : new DependencyRegistry();
-	if (stateArray && Array.isArray(stateArray)) collectDependencies(stateArray, registry);
+	const runtime = createDependencyRuntimeContext(preParsedContext.dependencyRegistry?.clone());
+	if (stateArray && Array.isArray(stateArray)) collectSourcesFromState(stateArray, runtime);
 	return {
 		context: {
 			...preParsedContext,
-			dependencyRegistry: registry
+			dependencyRegistry: runtime.registry
 		},
 		stateArray
 	};
@@ -2432,16 +2472,20 @@ function concat(...parsers) {
 	};
 	const completeSync = (state, exec) => {
 		const stateArray = state;
-		const combinedState = {};
-		for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
-		const resolvedCombinedState = resolveDeferredParseStates(combinedState);
+		const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+		const childExec = {
+			...exec,
+			dependencyRuntime: runtime,
+			preCompletedByParser: void 0
+		};
+		const resolvedArray = resolveStateWithRuntime(stateArray, runtime);
 		const results = [];
 		const deferredKeys = /* @__PURE__ */ new Map();
 		let hasDeferred = false;
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
-			const parserState = resolvedCombinedState[i];
-			const result = parser.complete(parserState, exec);
+			const parserState = prepareStateForCompletion(resolvedArray[i], parser);
+			const result = unwrapCompleteResult(parser.complete(parserState, childExec));
 			if (!result.success) return result;
 			const baseIndex = results.length;
 			if (Array.isArray(result.value)) {
@@ -2471,16 +2515,20 @@ function concat(...parsers) {
 	};
 	const completeAsync = async (state, exec) => {
 		const stateArray = state;
-		const combinedState = {};
-		for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
-		const resolvedCombinedState = await resolveDeferredParseStatesAsync(combinedState);
+		const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+		const childExec = {
+			...exec,
+			dependencyRuntime: runtime,
+			preCompletedByParser: void 0
+		};
+		const resolvedArray = await resolveStateWithRuntimeAsync(stateArray, runtime);
 		const results = [];
 		const deferredKeys = /* @__PURE__ */ new Map();
 		let hasDeferred = false;
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
-			const parserState = resolvedCombinedState[i];
-			const result = await parser.complete(parserState, exec);
+			const parserState = prepareStateForCompletion(resolvedArray[i], parser);
+			const result = unwrapCompleteResult(await parser.complete(parserState, childExec));
 			if (!result.success) return result;
 			const baseIndex = results.length;
 			if (Array.isArray(result.value)) {