Creating a reduce function that ignores children of a node - mapreduce

Question

I have a set of documents in couch DB that act as a tree. Each document includes an ancestors field that includes a list of IDs that represent the location in the tree of the current document. Some of the documents have a value associated with them (a number).
When a document does not have it's own value, it's implicit value is the maximum of all of it's children. But when a document does have it's own value, the value of any children is ignored. For example
Root (no value, no ancestors) effective value 7
Child1 (value 5, ancestors= Root) effective value 5
Grandchild1 (value 9, ancestors=Root,Child1) effective value 9
Child2 (no value, ancestors= Root) effective value 7
Grandchild2 (value 3, ancestors=Root,Child2) effective value 3
Grandchild3 (value 7, ancestors=Root,Child2) effective value 7
Child3 (value 6, ancestors= Root) effective value 6
I'm trying to build a view that allows me to get the effective value for a given node (I will have the full path so could key by path or id). So what I'm trying doing is:
Emit anything that has an explicit value in my map function
Build a reduce function that returns the explicit value for a node if it has one or finds the maximum of it's children if it doesn't.
I'm struggling to make this work because reduce appears to be run on partitions of the data. So I keep getting scenarios where the child and parent don't come together until a re-reduce so I lose the relationships and get the wrong value. e.g. with the above tree:
Grandchild 1 (value 9) and Grandchild 3 (value 7) end up on the same partition so are reduced first, resulting in value 9
Child 1 (value 5) is reduced with Child 3 (value 6) resulting in 6 being the winning value and dropping any knowledge of Child 1
The re-reduce happens to reduce Child 3 (value 6) and Grandchild 1 (value 9) and the resulting value is 9, because Child 1 is not involved in this reduce we don't know that the 9 should actually be replaced by a 5 so we get the wrong result.
Is it possible to implement this logic in a couch view reduce function?
My current implementations are:
Map Function
function (doc) {
if (doc.ancestors && doc.data) {
// For anything with a value emit it with the full path as the key
var path = doc.ancestors.concat([doc._id]);
emit(path, {data: doc.data, path: path})
}
}
Reduce Function
function (keys, values, rereduce) {
// build a tree of the values currently being reduced
// by reassembling the paths and putting the value
// at the targeted location
var tree = {children: {}};
function addValueToTree(value) {
var parent = tree;
value.path.forEach(function(docId) {
var newParent = parent.children[docId] || {children: {}};
parent.children[docId] = newParent;
parent = newParent;
});
parent.value = value;
}
values.forEach(addValueToTree);
// Object.entries isn't supported in Couch JS
// engine so simple polyfill
function entries(obj) {
var entries = [];
for (k in obj) {
entries.push([k, obj[k]]);
}
return entries;
}
// Determine the value of the tree selecting
// the one "winning" value to return from the
// reduce function
function reduceTree(tree, path) {
// If the node of the tree we're reducing has an
// explicit value then return that since it should
// take precedence over any children
if (tree.value) {
return tree.value;
}
// Otherwise reduce the children of the current node
// to get the "winning" node from
var toCombine = entries(tree.children).map(function (entry) {
return reduceTree(entry[1], path.concat([entry[0]]));
});
// Find the winning child by picking the one with
// the maximum value and return that
var ret = toCombine[0];
toCombine.forEach(function(child) {
if (child.data > ret.data)
ret = child;
});
return ret;
}
var ret = reduceTree(tree, []);
log({values: values, ret: ret})
return ret;
}
This works as long as descendants are reduced in the same invocation with any parent nodes that should take precedence, but when the parent ends up being dropped from the reduce (as in the example above) means the decedent is not replaced and can end up affecting the final calculation giving the wrong result.
I've tried gathering up the "contributing nodes" when reducing so that we retain the knowledge needed to know that a node is overwritten but that results in the "reduce function did not actually reduce the data" error.
Is this even possible with a reduce function or does it fundamentally break the constraints of a reduce function?