Facets come naturally out of delegated inheritance.

A facet is simply an object which accepts exactly the facet's
interface and delegates all of those operations to the real object.
The real object reference must remain confined.

This means that an object cannot store a reference to it's aggregate.
Object refers to the single layer, aggregate refers to what java would
call an object.  What if the most specific subtype happened to have
facets?  Which facet would more generic supertypes store as the
aggregate pointer?  Presumably, the real object.  Unless you trust the
generic supertype objects, there goes your confinement.

Perhaps you have to trust it anyway...?

The generic supertype object will get access to the aggregate reference
one way or another.  It has to, because it has to be able to invoke
through it.  It's not very useful to give to the supertype an
aggregate pointer that can only do what the original invoker of the
aggregate could do.  It may need a more powerful reference.

So, when you delegate to an object, you trust it not to leak the
aggregate pointer that you hand to it along with the delegation.