Exercise a multi-hop nested fill on the variant-anchored path

[nathanacurtis]

Problem

The path that anchors a slot fill onto an instance element can address a slot more than one instance boundary below that anchor, by recording the instance chain as a path. Nothing exercises it: every relation on the one screen tested so far was a single hop, so the deeper form is wired and unverified.

A composition nests layout components several levels deep, which is exactly where a multi-hop fill would occur, so the untested path is the one a real screen is most likely to hit.

Potential solution(s)

• Author a fixture whose non-default slot sits two or more instance boundaries below the anchor, and assert the recorded path
• Cover it at the unit level too, so the shape is pinned without a Figma round trip

Acceptance criteria

• A fixture exists whose filled non-default slot is two or more instance boundaries below the instance that anchors it
• The generated spec records the instance chain between anchor and slot, not a single hop
• The fill survives a round trip through Figma
• A unit test asserts the multi-hop shape independently of the fixture

Case data

• Workspace: specs-testing
• Territory: testing
• Size: s

Notes

#672 and #677 concern which slot is captured rather than how deep it sits, and #663 is parity rather than depth, so neither covers this.

The single-hop case is covered by existing unit tests, which assert an empty path explicitly — the deeper case is the gap.

---

Implementation details are tracked internally.

[nathanacurtis]

The fixture this needs, specified precisely

I could not author this one by rendering a spec, because the shape depends on a configuration render does not yet apply ($nested, now tracked in #684). So it needs authoring in Figma directly.

What makes a fill multi-hop is that the slot sits two or more instance boundaries below the instance that anchors it, without a slot in between. A slot crossed on the way resets the anchor, so the chain has to run through an instance's own internal anatomy rather than through its slots.

TEST Slot Deep Nested                     (the host)
└── Slot Outer                            (instance)
    └── … its own anatomy contains …
        └── Slot Two Slots                (instance, part of Outer's anatomy — NOT in a slot)
            └── slot "aside" → some text  (filled, as an override from the host)

The anchor is Slot Outer, the slot belongs to Slot Two Slots, and the recorded path should be [Slot Two Slots] — one entry, where every case tested so far recorded an empty path.

Two things make it fiddly, and are worth knowing before authoring:

• Slot Outer must be a new component whose own anatomy nests an instance of Slot Two Slots directly. None of the existing fixtures do this — in all of them the inner instance sits inside a slot.
• The aside fill has to be authored from the host, as an override reaching into the nested instance's nested instance. That is the whole point: it is the host's content, recorded against a slot two boundaries down.

What to assert once it exists

• The generated spec records the instance chain between anchor and slot, rather than a single hop
• The fill survives a render and re-capture
• A unit test pins the same shape without needing the fixture

The existing unit tests already assert the single-hop case explicitly, including that the path is empty, so the deeper case is the only gap.

[nathanacurtis]

Fixture built and the multi-hop shape is now exercised. Three of four criteria met; the fourth is blocked on #684.

The fixture

Two new components in specs-testing, authored as specs and rendered rather than drawn — which was possible only because the non-default slot fill landed in #673, so render could place the inner fill for me.

TEST Slot Deep Nested              (host)
└── TEST Slot Outer                (instance)
    └── TEST Slot Two Slots        (instance — in Outer's OWN anatomy, not a slot)
        └── slot "aside" → text "Aside two boundaries down"

The inner instance sitting in Outer's own anatomy is the whole trick: crossing a slot re-anchors, so a slot in between would collapse this back to one hop.

What the generated spec records

outer:
  propConfigurations:
    $nested:
      - path: [twoSlots]
        aside:
          $slotContent: "#/components/testSlotDeepNested/slotContentExamples/testSlotTwoSlots__aside__default"
  instanceOf: testSlotOuter

The anchor is outer, the path is [twoSlots] — non-empty, which is the first time that has happened. Every prior case recorded an empty path.

• a fixture exists whose filled non-default slot is two or more instance boundaries below the instance that anchors it
• the generated spec records the instance chain between anchor and slot, not a single hop
• a unit test asserts the multi-hop shape independently of the fixture
• the fill survives a round trip through Figma — blocked, see below

The unit tests

Two, in the slot-detection suite, and the second is the one that makes the first meaningful:

• the multi-hop case asserts nestedInstancePath: ['Two Slots'] with the anchor as the outer instance
• a control case puts the inner instance inside Outer's slot instead, and asserts the path collapses to [] with the inner instance becoming the anchor — so the test would fail if re-anchoring stopped working, rather than passing for the wrong reason

Why the round trip cannot close yet

Render does not apply a $nested configuration — it warns, naming the path it could not reach. So rendering the captured spec would place the outer instance and lose the deep fill. That is #684's remaining half, not a gap in the fixture.

The fixture is what unblocks testing it: once $nested renders, this is the case to round-trip.

One note for whoever marks fixtures

Both components are rendered into the file but not marked ready for dev, so a scan excludes them and generate -c cannot find them by name. Their specs are in the workspace, generated by node id. Marking them would make them part of the ordinary catalogue.

[nathanacurtis]

Last criterion met. $nested now renders, so the multi-hop fill survives a full round trip.

in   $nested: [{ path: [twoSlots], aside: { $slotContent: … } }]
     entry: testSlotTwoSlots__aside__default → "Aside two boundaries down"

out  $nested: [{ path: [twoSlots], aside: { $slotContent: … } }]   identical
     entry: testSlotTwoSlots__aside__default → "Aside two boundaries down"
     anatomy, layout: identical

• a fixture exists whose filled non-default slot is two or more instance boundaries below the instance that anchors it
• the generated spec records the instance chain between anchor and slot, not a single hop
• the fill survives a round trip through Figma
• a unit test asserts the multi-hop shape independently of the fixture

The render side is tracked under #684, where the $nested half landed alongside the image bindings.

One detail worth recording, because it is the thing that makes the walk correct: resolving a path follows instances in each one's own anatomy and never crosses a slot. That is the same boundary capture drew when it recorded the path — crossing a slot re-anchors on the read side, so a path never spans one, and following one here would resolve to a different instance than the path means. The two directions now draw the identical boundary, which is what lets the round trip be identical rather than merely close.