UserAgent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.16 Safari/537.36

Steps to reproduce the problem:
<script>
  class TheMother extends HTMLElement {
    constructor(){
      super();
      this.attachShadow({mode: "open"});
      this.shadowRoot.innerHTML = "<the-son><slot></slot></the-son>";
    }
  }
  class TheFather extends HTMLElement {
    constructor(){
      super();
      this.attachShadow({mode: "open"});
      this.shadowRoot.innerHTML = "<the-son><slot>father decides</slot></the-son>";
    }
  }
  class TheSon extends HTMLElement {
    constructor(){
      super();
      this.attachShadow({mode: "open"});
      this.shadowRoot.innerHTML = "<b><slot>son decides</slot></b>";
    }
  }
  customElements.define("the-mother", TheMother); 
  customElements.define("the-father", TheFather); 
  customElements.define("the-son", TheSon);
</script>

#son <the-son id="son">God decides</the-son><hr>
#son2 <the-son id="son2"></the-son><hr>
#son3 <the-son id="son3"><slot>God again</slot></the-son><hr>
#son4 <the-son id="son4"><slot></slot></the-son><hr>
#pap <the-father id="pap">God decides</the-father><hr>
#pap2 <the-father id="pap2"></the-father><hr>
#pap3 <the-father id="pap3"><slot>God again</slot></the-father><hr>
#pap4 <the-father id="pap4"><slot></slot></the-father><hr>
#mom <the-mother id="mom">God decides</the-mother><hr>
#mom2 (????)<the-mother id="mom2"></the-mother><hr>
#mom3 <the-mother id="mom3"><slot>God again</slot></the-mother><hr>
#mom4 <the-mother id="mom4"><slot></slot></the-mother><hr>

<script>
  function whoDecides(selector){
    let parent = document.querySelector(selector);
    while (parent.tagName !== "THE-SON")
      parent = parent.shadowRoot.children[0];
    const sonSlot = parent.shadowRoot.children[0].children[0];
    const assigned = sonSlot.assignedNodes({flatten: true});
    console.log(selector, assigned[0]);
  } 
  whoDecides("#son");
  whoDecides("#son2");
  whoDecides("#son3");
  whoDecides("#son4");  
  whoDecides("#pap");
  whoDecides("#pap2");
  whoDecides("#pap3");
  whoDecides("#pap4");
  whoDecides("#mom");
  whoDecides("#mom2");
  whoDecides("#mom3");
  whoDecides("#mom4");
</script> 

What is the expected behavior?
slot in son of #mom2 .assignedNodes({flatten: true}) should return []

What went wrong?
slot in son of #mom2 .assignedNodes({flatten: true}) did return []

Did this work before? N/A 

Does this work in other browsers? No
 Firefox with web comps enabled returns undefined in even more situations.

Chrome version: 70.0.3538.16  Channel: n/a
OS Version: 
Flash Version: 

The template of this test tries to illustrate the decision hierarchy in a family (of slots).

#mom2 problem: If you wrap a custom element inside another custom element, and you want to use the inner elements fallback content within it, how do you accomplish that? The mom does not want to replace the empty slot fallback value of the son with her own. #pap2 does that.

Chrome .assignedNodes({flatten: true}) returns undefined for #mom2 in Chrome.
Firefox .assignedNodes({flatten: true}) returns undefined for #son3,4 #pap3,4, #mom2,3,4.
Also. It would be good if the .assignedNodes({flatten: true}) would replace the slot nodes with its .childNodes instead. It would unify the resolution of both normally slotted DOM nodes, and the fallback DOM nodes. This would be more inline with what (I as) a developer would anticipate.

Today, the standard reads:
----------------------------------
To find flattened slotables for a given slot slot, run these steps:

1. Let result be an empty list.

2. If slot’s root is not a shadow root, then return result.

3. Let slotables be the result of finding slotables given slot.

4. If slotables is the empty list, then append each slotable child of slot, in tree order, to slotables.

5. For each node in slotables:

5. 1. If node is a slot whose root is a shadow root, then:

5. 1. 1. Let temporaryResult be the result of finding flattened slotables given node.

5. 1. 2. Append each slotable in temporaryResult, in order, to result.

5. 2. Otherwise, append node to result.

6. Return result.
----------------------------------

What if the rule instead was?
----------------------------------
1. Let result be an empty list.

2. Let slotables be the result of finding slotables given slot.

3. For each node in slotables:

3. 1. If node is a slot, then:

3. 1. 1. Let temporaryResult be the result of finding flattened slotables given node.

3. 1. 2. Append each slotable in temporaryResult, in order, to result.

4. If slotables is the empty list, then append each slotable child of slot, in tree order, to slotables.

5. Return result.
----------------------------------

This would more or less accomplish the same result, but it would fix the problem with #mom2? And it would unify the treatment of slotted nodes and fallbcak childNodes?

A problem: If you add an empty slot that has nothing assigned to it, then that slot will hide the fallback content in the previous setup. But this feature is a little bit magic know-how. And default slot content could still be hidden using just a whitespace in the tag.