This is perhaps too narrow a trick to rank as a pattern, yet I have seen it appear in more than one context.

In Keykos the most common facet implementation is the data byte. The 256 possible data bytes in a start key provide only that many facets. When the facet is used to access one function over other possible functions supported by the object this is likely to be enough. When a facet is to access one conceptual instance among a dynamic set, 256 is not generally enough. This latter case is typified by a domain that multiplexes some particular communications link. The domain needs to disseminate a facet per multiplexed channel on that link. (This is actually multiple instances of objects. This material should be reorganized to reflect this.)

Two closely related tricks were used to accommodate this in Keykos. One required a kernel hack, the other did not. In each case the invocation of a facet was via an intermediary, one per facet, or perhaps one per 256 facets. The multifaceted code receives a message somehow augmented by the intermediary so as to identify the facet.

Without kernel enhancement the intermediary would merely be a domain with enough constant state to know its own identity which it appends to the invocation message. This facet ID can indeed be a capability if that is convenient, as it often is. The intermediary might retain the resume key of the caller and call the base domain, or it might pass on the resume key to the base domain. In either case the domain queuing and stalling logic work naturally.

With the kernel enhancement the intermediary is special node via which the invocation message is indirected. Historically this was a discovered pattern with the red segment node. The mature form is as follows, however. A key type, known to the kernel, designates a node. Slot 15 of that node holds a number key with a few fields interpreted by the kernel. When a key of this type is invoked the kernel consults an architected slot of the node for the start key to the base domain that obeys the code that interprets the augmented invocation message. With this kernel enhancement invoking an indirect node stalls the invoker if the base node is not available. So far this could describe a segmode key. A bit in slot 15 might indicate the following kernel action: put the last key from the invocation message in an architected slot and replace that key with a node key to the node as the message is delivered to the base domain. The original message is available to the base domain along with a node key with which it can access state relevant to the particular facet. This form of indirection node is much like the RAM block with which C++ embodies an instance.