Retain import inclusion graph during acquisition

internal/engine/load_input.go

@@ -23,37 +23,51 @@ type assembledInput struct {
 // boundary for later scoped assembly and evidence.
 type acquiredContribution struct {
 	source              SourceInfo
+	identity            importNodeKey
+	role                importContributionRole
+	scopeOwner          importNodeKey
 	payload             *document.Node
 	document            *document.Node
 	destination         Path
 	relativeDestination Path
 	processing          *sourceVersionProcessingResult
 	nested              *composedDocument
+	pendingItem         *acquisitionScope
 }
 
 // acquisitionScope is the ordered strict mapping scope produced by one input
 // and its ordinary imports.
 type acquisitionScope struct {
+	owner         importNodeKey
 	destination   Path
 	contributions []acquiredContribution
 }
 
 func cloneAcquisitionScope(scope acquisitionScope) acquisitionScope {
-	cloned := acquisitionScope{destination: scope.destination.clone()}
+	cloned := acquisitionScope{owner: scope.owner, destination: scope.destination.clone()}
 	if scope.contributions != nil {
 		cloned.contributions = make([]acquiredContribution, len(scope.contributions))
 		for index, contribution := range scope.contributions {
 			cloned.contributions[index] = acquiredContribution{
-				source: cloneSourceInfo(contribution.source), payload: contribution.payload,
+				source: cloneSourceInfo(contribution.source), identity: contribution.identity,
+				role: contribution.role, scopeOwner: contribution.scopeOwner, payload: contribution.payload,
 				document: contribution.document, destination: contribution.destination.clone(),
 				relativeDestination: contribution.relativeDestination.clone(), processing: contribution.processing,
-				nested: cloneComposedDocument(contribution.nested),
+				nested: cloneComposedDocument(contribution.nested), pendingItem: cloneAcquisitionScopePointer(contribution.pendingItem),
 			}
 		}
 	}
 	return cloned
 }
 
+func cloneAcquisitionScopePointer(scope *acquisitionScope) *acquisitionScope {
+	if scope == nil {
+		return nil
+	}
+	cloned := cloneAcquisitionScope(*scope)
+	return &cloned
+}
+
 func cloneAcquisitionScopes(scopes []acquisitionScope) []acquisitionScope {
 	if scopes == nil {
 		return nil
@@ -145,10 +159,13 @@ func assembleBaseInputTrackedForRole[T any](source Source, options Options[T], d
 		}
 		localPayload := input.document
 		input.document = placed
+		identity := importKeyForMainSource(parsed.source)
 		input.acquisition = []acquisitionScope{{
+			owner:       identity,
 			destination: destination.clone(),
 			contributions: []acquiredContribution{{
 				source: cloneSourceInfo(*parsed.source), payload: localPayload,
+				identity: identity, role: importRoleMain, scopeOwner: identity,
 				document: placed, destination: destination.clone(), processing: versionProcessing,
 			}},
 		}}