@optique/core 0.10.0-dev.294 → 0.10.0-dev.296

package/dist/constructs.cjs

@@ -243,11 +243,38 @@ function or(...args) {
 				state: 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) return {
-					success: false,
-					consumed: context.buffer.length - result.next.buffer.length,
-					error: require_message.message`${require_message.values(context.state[1].consumed)} and ${require_message.values(result.consumed)} cannot be used together.`
-				};
+				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
+					});
+					const canConsumeShared = checkResult.success && checkResult.consumed.length === previouslyConsumed.length && checkResult.consumed.every((c, idx) => c === previouslyConsumed[idx]);
+					if (!canConsumeShared) return {
+						success: false,
+						consumed: context.buffer.length - result.next.buffer.length,
+						error: require_message.message`${require_message.values(context.state[1].consumed)} and ${require_message.values(result.consumed)} cannot be used together.`
+					};
+					const replayedResult = parser.parse({
+						...context,
+						state: checkResult.next.state
+					});
+					if (!replayedResult.success) return replayedResult;
+					return {
+						success: true,
+						next: {
+							...context,
+							buffer: replayedResult.next.buffer,
+							optionsTerminated: replayedResult.next.optionsTerminated,
+							state: [i, {
+								...replayedResult,
+								consumed: [...previouslyConsumed, ...replayedResult.consumed]
+							}]
+						},
+						consumed: replayedResult.consumed
+					};
+				}
 				return {
 					success: true,
 					next: {
@@ -276,11 +303,40 @@ function or(...args) {
 			});
 			const result = await resultOrPromise;
 			if (result.success && result.consumed.length > 0) {
-				if (context.state?.[0] !== i && context.state?.[1].success) return {
-					success: false,
-					consumed: context.buffer.length - result.next.buffer.length,
-					error: require_message.message`${require_message.values(context.state[1].consumed)} and ${require_message.values(result.consumed)} cannot be used together.`
-				};
+				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
+					});
+					const checkResult = await checkResultOrPromise;
+					const canConsumeShared = checkResult.success && checkResult.consumed.length === previouslyConsumed.length && checkResult.consumed.every((c, idx) => c === previouslyConsumed[idx]);
+					if (!canConsumeShared) return {
+						success: false,
+						consumed: context.buffer.length - result.next.buffer.length,
+						error: require_message.message`${require_message.values(context.state[1].consumed)} and ${require_message.values(result.consumed)} cannot be used together.`
+					};
+					const replayedResultOrPromise = parser.parse({
+						...context,
+						state: checkResult.next.state
+					});
+					const replayedResult = await replayedResultOrPromise;
+					if (!replayedResult.success) return replayedResult;
+					return {
+						success: true,
+						next: {
+							...context,
+							buffer: replayedResult.next.buffer,
+							optionsTerminated: replayedResult.next.optionsTerminated,
+							state: [i, {
+								...replayedResult,
+								consumed: [...previouslyConsumed, ...replayedResult.consumed]
+							}]
+						},
+						consumed: replayedResult.consumed
+					};
+				}
 				return {
 					success: true,
 					next: {
@@ -848,12 +904,46 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			return parseSync(context);
 		},
 		complete(state) {
-			const resolvedState = isAsync ? state : resolveDeferredParseStates(state);
 			if (!isAsync) {
+				const preCompletedState = {};
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldState = state[fieldKey];
+					const fieldParser = parsers[field];
+					if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) {
+						const completed = fieldParser.complete(fieldState);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) {
+						const completed = fieldParser.complete([fieldParser.initialState]);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
+						const pendingState = fieldParser[require_dependency.WrappedDependencySourceMarker];
+						const completed = fieldParser.complete([pendingState]);
+						if (require_dependency.isDependencySourceState(completed)) preCompletedState[fieldKey] = completed;
+						else preCompletedState[fieldKey] = fieldState;
+					} else preCompletedState[fieldKey] = fieldState;
+				}
+				const resolvedState = resolveDeferredParseStates(preCompletedState);
 				const result = {};
 				for (const field of parserKeys) {
-					const valueResult = parsers[field].complete(resolvedState[field]);
-					if (valueResult.success) result[field] = valueResult.value;
+					const fieldKey = field;
+					const fieldResolvedState = resolvedState[fieldKey];
+					const fieldParser = parsers[field];
+					const originalFieldState = state[fieldKey];
+					const wasPreCompletedCase1 = Array.isArray(originalFieldState) && originalFieldState.length === 1 && require_dependency.isPendingDependencySourceState(originalFieldState[0]);
+					const wasPreCompletedCase2 = originalFieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState);
+					const wasPreCompletedCase3 = originalFieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser);
+					if (require_dependency.isDependencySourceState(fieldResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
+						const depResult = fieldResolvedState.result;
+						if (depResult.success) result[fieldKey] = depResult.value;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = fieldParser.complete(fieldResolvedState);
+					if (valueResult.success) result[fieldKey] = valueResult.value;
 					else return {
 						success: false,
 						error: valueResult.error
@@ -865,11 +955,45 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				};
 			}
 			return (async () => {
-				const resolvedState$1 = await resolveDeferredParseStatesAsync(state);
+				const preCompletedState = {};
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldState = state[fieldKey];
+					const fieldParser = parsers[field];
+					if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) {
+						const completed = await fieldParser.complete(fieldState);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) {
+						const completed = await fieldParser.complete([fieldParser.initialState]);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
+						const pendingState = fieldParser[require_dependency.WrappedDependencySourceMarker];
+						const completed = await fieldParser.complete([pendingState]);
+						if (require_dependency.isDependencySourceState(completed)) preCompletedState[fieldKey] = completed;
+						else preCompletedState[fieldKey] = fieldState;
+					} else preCompletedState[fieldKey] = fieldState;
+				}
+				const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
 				const result = {};
 				for (const field of parserKeys) {
-					const valueResult = await parsers[field].complete(resolvedState$1[field]);
-					if (valueResult.success) result[field] = valueResult.value;
+					const fieldKey = field;
+					const fieldResolvedState = resolvedState[fieldKey];
+					const fieldParser = parsers[field];
+					const originalFieldState = state[fieldKey];
+					const wasPreCompletedCase1 = Array.isArray(originalFieldState) && originalFieldState.length === 1 && require_dependency.isPendingDependencySourceState(originalFieldState[0]);
+					const wasPreCompletedCase2 = originalFieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState);
+					const wasPreCompletedCase3 = originalFieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser);
+					if (require_dependency.isDependencySourceState(fieldResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
+						const depResult = fieldResolvedState.result;
+						if (depResult.success) result[fieldKey] = depResult.value;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = await fieldParser.complete(fieldResolvedState);
+					if (valueResult.success) result[fieldKey] = valueResult.value;
 					else return {
 						success: false,
 						error: valueResult.error
@@ -1096,10 +1220,43 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		},
 		complete(state) {
 			if (!isAsync) {
-				const result = [];
 				const stateArray = state;
+				const preCompletedState = [];
 				for (let i = 0; i < syncParsers.length; i++) {
-					const valueResult = syncParsers[i].complete(stateArray[i]);
+					const elementState = stateArray[i];
+					const elementParser = syncParsers[i];
+					if (Array.isArray(elementState) && elementState.length === 1 && require_dependency.isPendingDependencySourceState(elementState[0])) {
+						const completed = elementParser.complete(elementState);
+						preCompletedState[i] = completed;
+					} else if (elementState === void 0 && require_dependency.isPendingDependencySourceState(elementParser.initialState)) {
+						const completed = elementParser.complete([elementParser.initialState]);
+						preCompletedState[i] = completed;
+					} else if (elementState === void 0 && require_dependency.isWrappedDependencySource(elementParser)) {
+						const pendingState = elementParser[require_dependency.WrappedDependencySourceMarker];
+						const completed = elementParser.complete([pendingState]);
+						preCompletedState[i] = completed;
+					} else preCompletedState[i] = elementState;
+				}
+				const resolvedState = resolveDeferredParseStates(preCompletedState);
+				const resolvedArray = resolvedState;
+				const result = [];
+				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 && require_dependency.isPendingDependencySourceState(originalElementState[0]);
+					const wasPreCompletedCase2 = originalElementState === void 0 && require_dependency.isPendingDependencySourceState(elementParser.initialState);
+					const wasPreCompletedCase3 = originalElementState === void 0 && require_dependency.isWrappedDependencySource(elementParser);
+					if (require_dependency.isDependencySourceState(elementResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
+						const depResult = elementResolvedState.result;
+						if (depResult.success) result[i] = depResult.value;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = elementParser.complete(elementResolvedState);
 					if (valueResult.success) result[i] = valueResult.value;
 					else return {
 						success: false,
@@ -1112,10 +1269,43 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				};
 			}
 			return (async () => {
-				const result = [];
 				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 && require_dependency.isPendingDependencySourceState(elementState[0])) {
+						const completed = await elementParser.complete(elementState);
+						preCompletedState[i] = completed;
+					} else if (elementState === void 0 && require_dependency.isPendingDependencySourceState(elementParser.initialState)) {
+						const completed = await elementParser.complete([elementParser.initialState]);
+						preCompletedState[i] = completed;
+					} else if (elementState === void 0 && require_dependency.isWrappedDependencySource(elementParser)) {
+						const pendingState = elementParser[require_dependency.WrappedDependencySourceMarker];
+						const completed = await elementParser.complete([pendingState]);
+						preCompletedState[i] = completed;
+					} else preCompletedState[i] = elementState;
+				}
+				const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
+				const resolvedArray = resolvedState;
+				const result = [];
 				for (let i = 0; i < parsers.length; i++) {
-					const valueResult = await parsers[i].complete(stateArray[i]);
+					const elementResolvedState = resolvedArray[i];
+					const elementParser = parsers[i];
+					const originalElementState = stateArray[i];
+					const wasPreCompletedCase1 = Array.isArray(originalElementState) && originalElementState.length === 1 && require_dependency.isPendingDependencySourceState(originalElementState[0]);
+					const wasPreCompletedCase2 = originalElementState === void 0 && require_dependency.isPendingDependencySourceState(elementParser.initialState);
+					const wasPreCompletedCase3 = originalElementState === void 0 && require_dependency.isWrappedDependencySource(elementParser);
+					if (require_dependency.isDependencySourceState(elementResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
+						const depResult = elementResolvedState.result;
+						if (depResult.success) result[i] = depResult.value;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = await elementParser.complete(elementResolvedState);
 					if (valueResult.success) result[i] = valueResult.value;
 					else return {
 						success: false,
@@ -1576,11 +1766,14 @@ function concat(...parsers) {
 		};
 	};
 	const completeSync = (state) => {
-		const results = [];
 		const stateArray = state;
+		const combinedState = {};
+		for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
+		const resolvedCombinedState = resolveDeferredParseStates(combinedState);
+		const results = [];
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
-			const parserState = stateArray[i];
+			const parserState = resolvedCombinedState[i];
 			const result = parser.complete(parserState);
 			if (!result.success) return result;
 			if (Array.isArray(result.value)) results.push(...result.value);
@@ -1592,11 +1785,14 @@ function concat(...parsers) {
 		};
 	};
 	const completeAsync = async (state) => {
-		const results = [];
 		const stateArray = state;
+		const combinedState = {};
+		for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
+		const resolvedCombinedState = await resolveDeferredParseStatesAsync(combinedState);
+		const results = [];
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
-			const parserState = stateArray[i];
+			const parserState = resolvedCombinedState[i];
 			const result = await parser.complete(parserState);
 			if (!result.success) return result;
 			if (Array.isArray(result.value)) results.push(...result.value);

package/dist/constructs.js

@@ -1,5 +1,5 @@
 import { message, optionName, values } from "./message.js";
-import { DependencyId, DependencyRegistry, ParseWithDependency, isDeferredParseState, isDependencySourceState } from "./dependency.js";
+import { DependencyId, DependencyRegistry, ParseWithDependency, WrappedDependencySourceMarker, isDeferredParseState, isDependencySourceState, isPendingDependencySourceState, isWrappedDependencySource } from "./dependency.js";
 import { extractArgumentMetavars, extractCommandNames, extractOptionNames } from "./usage.js";
 import { createErrorWithSuggestions, deduplicateSuggestions } from "./suggestion.js";
 
@@ -243,11 +243,38 @@ function or(...args) {
 				state: 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) return {
-					success: false,
-					consumed: context.buffer.length - result.next.buffer.length,
-					error: message`${values(context.state[1].consumed)} and ${values(result.consumed)} cannot be used together.`
-				};
+				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
+					});
+					const canConsumeShared = checkResult.success && checkResult.consumed.length === previouslyConsumed.length && checkResult.consumed.every((c, idx) => c === previouslyConsumed[idx]);
+					if (!canConsumeShared) return {
+						success: false,
+						consumed: context.buffer.length - result.next.buffer.length,
+						error: message`${values(context.state[1].consumed)} and ${values(result.consumed)} cannot be used together.`
+					};
+					const replayedResult = parser.parse({
+						...context,
+						state: checkResult.next.state
+					});
+					if (!replayedResult.success) return replayedResult;
+					return {
+						success: true,
+						next: {
+							...context,
+							buffer: replayedResult.next.buffer,
+							optionsTerminated: replayedResult.next.optionsTerminated,
+							state: [i, {
+								...replayedResult,
+								consumed: [...previouslyConsumed, ...replayedResult.consumed]
+							}]
+						},
+						consumed: replayedResult.consumed
+					};
+				}
 				return {
 					success: true,
 					next: {
@@ -276,11 +303,40 @@ function or(...args) {
 			});
 			const result = await resultOrPromise;
 			if (result.success && result.consumed.length > 0) {
-				if (context.state?.[0] !== i && context.state?.[1].success) return {
-					success: false,
-					consumed: context.buffer.length - result.next.buffer.length,
-					error: message`${values(context.state[1].consumed)} and ${values(result.consumed)} cannot be used together.`
-				};
+				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
+					});
+					const checkResult = await checkResultOrPromise;
+					const canConsumeShared = checkResult.success && checkResult.consumed.length === previouslyConsumed.length && checkResult.consumed.every((c, idx) => c === previouslyConsumed[idx]);
+					if (!canConsumeShared) return {
+						success: false,
+						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({
+						...context,
+						state: checkResult.next.state
+					});
+					const replayedResult = await replayedResultOrPromise;
+					if (!replayedResult.success) return replayedResult;
+					return {
+						success: true,
+						next: {
+							...context,
+							buffer: replayedResult.next.buffer,
+							optionsTerminated: replayedResult.next.optionsTerminated,
+							state: [i, {
+								...replayedResult,
+								consumed: [...previouslyConsumed, ...replayedResult.consumed]
+							}]
+						},
+						consumed: replayedResult.consumed
+					};
+				}
 				return {
 					success: true,
 					next: {
@@ -848,12 +904,46 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			return parseSync(context);
 		},
 		complete(state) {
-			const resolvedState = isAsync ? state : resolveDeferredParseStates(state);
 			if (!isAsync) {
+				const preCompletedState = {};
+				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);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState)) {
+						const completed = fieldParser.complete([fieldParser.initialState]);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
+						const pendingState = fieldParser[WrappedDependencySourceMarker];
+						const completed = fieldParser.complete([pendingState]);
+						if (isDependencySourceState(completed)) preCompletedState[fieldKey] = completed;
+						else preCompletedState[fieldKey] = fieldState;
+					} else preCompletedState[fieldKey] = fieldState;
+				}
+				const resolvedState = resolveDeferredParseStates(preCompletedState);
 				const result = {};
 				for (const field of parserKeys) {
-					const valueResult = parsers[field].complete(resolvedState[field]);
-					if (valueResult.success) result[field] = valueResult.value;
+					const fieldKey = field;
+					const fieldResolvedState = resolvedState[fieldKey];
+					const fieldParser = parsers[field];
+					const originalFieldState = state[fieldKey];
+					const wasPreCompletedCase1 = Array.isArray(originalFieldState) && originalFieldState.length === 1 && isPendingDependencySourceState(originalFieldState[0]);
+					const wasPreCompletedCase2 = originalFieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState);
+					const wasPreCompletedCase3 = originalFieldState === void 0 && isWrappedDependencySource(fieldParser);
+					if (isDependencySourceState(fieldResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
+						const depResult = fieldResolvedState.result;
+						if (depResult.success) result[fieldKey] = depResult.value;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = fieldParser.complete(fieldResolvedState);
+					if (valueResult.success) result[fieldKey] = valueResult.value;
 					else return {
 						success: false,
 						error: valueResult.error
@@ -865,11 +955,45 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				};
 			}
 			return (async () => {
-				const resolvedState$1 = await resolveDeferredParseStatesAsync(state);
+				const preCompletedState = {};
+				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);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState)) {
+						const completed = await fieldParser.complete([fieldParser.initialState]);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && isWrappedDependencySource(fieldParser)) {
+						const pendingState = fieldParser[WrappedDependencySourceMarker];
+						const completed = await fieldParser.complete([pendingState]);
+						if (isDependencySourceState(completed)) preCompletedState[fieldKey] = completed;
+						else preCompletedState[fieldKey] = fieldState;
+					} else preCompletedState[fieldKey] = fieldState;
+				}
+				const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
 				const result = {};
 				for (const field of parserKeys) {
-					const valueResult = await parsers[field].complete(resolvedState$1[field]);
-					if (valueResult.success) result[field] = valueResult.value;
+					const fieldKey = field;
+					const fieldResolvedState = resolvedState[fieldKey];
+					const fieldParser = parsers[field];
+					const originalFieldState = state[fieldKey];
+					const wasPreCompletedCase1 = Array.isArray(originalFieldState) && originalFieldState.length === 1 && isPendingDependencySourceState(originalFieldState[0]);
+					const wasPreCompletedCase2 = originalFieldState === void 0 && isPendingDependencySourceState(fieldParser.initialState);
+					const wasPreCompletedCase3 = originalFieldState === void 0 && isWrappedDependencySource(fieldParser);
+					if (isDependencySourceState(fieldResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
+						const depResult = fieldResolvedState.result;
+						if (depResult.success) result[fieldKey] = depResult.value;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = await fieldParser.complete(fieldResolvedState);
+					if (valueResult.success) result[fieldKey] = valueResult.value;
 					else return {
 						success: false,
 						error: valueResult.error
@@ -1096,10 +1220,43 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		},
 		complete(state) {
 			if (!isAsync) {
-				const result = [];
 				const stateArray = state;
+				const preCompletedState = [];
 				for (let i = 0; i < syncParsers.length; i++) {
-					const valueResult = syncParsers[i].complete(stateArray[i]);
+					const elementState = stateArray[i];
+					const elementParser = syncParsers[i];
+					if (Array.isArray(elementState) && elementState.length === 1 && isPendingDependencySourceState(elementState[0])) {
+						const completed = elementParser.complete(elementState);
+						preCompletedState[i] = completed;
+					} else if (elementState === void 0 && isPendingDependencySourceState(elementParser.initialState)) {
+						const completed = elementParser.complete([elementParser.initialState]);
+						preCompletedState[i] = completed;
+					} else if (elementState === void 0 && isWrappedDependencySource(elementParser)) {
+						const pendingState = elementParser[WrappedDependencySourceMarker];
+						const completed = elementParser.complete([pendingState]);
+						preCompletedState[i] = completed;
+					} else preCompletedState[i] = elementState;
+				}
+				const resolvedState = resolveDeferredParseStates(preCompletedState);
+				const resolvedArray = resolvedState;
+				const result = [];
+				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;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = elementParser.complete(elementResolvedState);
 					if (valueResult.success) result[i] = valueResult.value;
 					else return {
 						success: false,
@@ -1112,10 +1269,43 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				};
 			}
 			return (async () => {
-				const result = [];
 				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);
+						preCompletedState[i] = completed;
+					} else if (elementState === void 0 && isPendingDependencySourceState(elementParser.initialState)) {
+						const completed = await elementParser.complete([elementParser.initialState]);
+						preCompletedState[i] = completed;
+					} else if (elementState === void 0 && isWrappedDependencySource(elementParser)) {
+						const pendingState = elementParser[WrappedDependencySourceMarker];
+						const completed = await elementParser.complete([pendingState]);
+						preCompletedState[i] = completed;
+					} else preCompletedState[i] = elementState;
+				}
+				const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
+				const resolvedArray = resolvedState;
+				const result = [];
 				for (let i = 0; i < parsers.length; i++) {
-					const valueResult = await parsers[i].complete(stateArray[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;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = await elementParser.complete(elementResolvedState);
 					if (valueResult.success) result[i] = valueResult.value;
 					else return {
 						success: false,
@@ -1576,11 +1766,14 @@ function concat(...parsers) {
 		};
 	};
 	const completeSync = (state) => {
-		const results = [];
 		const stateArray = state;
+		const combinedState = {};
+		for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
+		const resolvedCombinedState = resolveDeferredParseStates(combinedState);
+		const results = [];
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
-			const parserState = stateArray[i];
+			const parserState = resolvedCombinedState[i];
 			const result = parser.complete(parserState);
 			if (!result.success) return result;
 			if (Array.isArray(result.value)) results.push(...result.value);
@@ -1592,11 +1785,14 @@ function concat(...parsers) {
 		};
 	};
 	const completeAsync = async (state) => {
-		const results = [];
 		const stateArray = state;
+		const combinedState = {};
+		for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
+		const resolvedCombinedState = await resolveDeferredParseStatesAsync(combinedState);
+		const results = [];
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
-			const parserState = stateArray[i];
+			const parserState = resolvedCombinedState[i];
 			const result = await parser.complete(parserState);
 			if (!result.success) return result;
 			if (Array.isArray(result.value)) results.push(...result.value);