path shelf characteristic

[matt-beanland]

Improve the path so that it populates a shelf characteristic based on the shelf related via the card from its assigned port.

I think this data should be persisted on a characteristic on the path, which means we probably need an update action 'refresh' to update the characteristic based on traversal of the reverse relationship. We could persist the forward relationship to the shelf, then derive the characteristic using calculations.

[matt-beanland]

Yarned about this with the diffo 0.4.0 primitives in hand and a clean shape fell out — turtles all the way down.

Each layer brings up what's below; each slot expects what's above:

• Shelf: just is — its characteristic carries device_name, family, model, technology.
• Card: brings up shelf into its own value via a calc that traverses the reverse :contains relationship to its parent shelf. The card composes shelf into its identity, so a consumer reading the card sees both card and shelf fields.
• Port (the slot, an AssignableCharacteristic entry on the card): expects whatever assigns into it to bring up shelf. The slot is a contract — not "this is the shelf" but "whoever fills me knows shelf."
• Path: gets a port assigned. Reads the port's expectation as its own. Path is installed when the assignment chain delivers the shelf the port expected.

No instance has to declare more than its immediate hop. Each declares what it brings up (calc that traverses one step below) and what it expects from below (outstanding/expectation on its assignable slot). Installation isn't asserted from above — it's the alignment of every layer's expectation through the graph.

That matches what diffo 0.4.0 already exposes:

• FieldViaAssignedRelationship / inherited_place for the bringing up (read one step away).
• Alias-keyed AssignmentRelationship for the expectations (each slot has an alias, the assignment record carries the same alias, expectations join on alias).
• AshOutstanding outstanding do expect [...] for declaring what a value must contain.

The old framing in the body — "an update action 'refresh' to update the characteristic" — is the snapshot/mined mental model. The 0.4.0 primitives let us derive instead: shelf on path is a live calculation, not a refreshed attribute. No refresh action, no persistence, no drift.

This also lands #3's choreography vision concretely. Persistent first-order expectations on slots, each instance watching its own world, the whole emerging from alignment rather than direction. Dancers, not command-and-control.

[matt-beanland]

Landed on 10-shelf-on-path. Turtles-down working end-to-end.

What landed:

• DiffoExample.Calculations.InheritedCharacteristic — local calc module that mirrors Diffo.Provider.Calculations.InheritedPlace but reads typed characteristic values from the assignment source. ~50 lines including docs.
• Card has :shelf calc — brings up the shelf's typed characteristic value via via: [:slot].
• Path has :card calc — brings up the card's typed characteristic value via via: [:port].
• Path has :shelf calc — brings up the shelf's typed characteristic value via the two-hop via: [:port, :slot]. Single calc, transitive bring-up.
• Path has :port calc — the integer port number from the assignment record itself, via Diffo.Provider.Calculations.FieldFromAssignment.

Aliases on assignments are the assignee's slot names. The path-test create_dslam_with_line_card helper updated so the card-as-assignee names its slot :slot when requesting from shelf, and the path-as-assignee names its slot :port when requesting from card. Existing tests that assign without aliases stay unchanged — alias is optional unless the consumer wants multiple assignments or wants downstream calcs to traverse by name.

Test assertion in test/access/path_test.exs "relate cables and dslam":

{:ok, path_with_brought_up} = Ash.load(path, [:card, :shelf, :port])

[%{family: :ISAM, model: "EBLT48", technology: :adsl2Plus}] = path_with_brought_up.card

[%{device_name: "QDONC-0001", family: :ISAM, model: "ISAM7330", technology: :DSLAM}] =
  path_with_brought_up.shelf

assert path_with_brought_up.port == [1]

Live bring-up. No snapshot. No refresh action. Each instance shows itself; what's brought up is derived at read time via the assignment graph.

Upstreamed as diffo#172 — proposes the inherited_characteristic DSL declaration and backing calc module so the local implementation can move to diffo and consumers stop writing the wiring per-domain. Our local InheritedCharacteristic is the working implementation, ready to lift.

[matt-beanland]

Resource shape landed on the 10-shelf-on-path branch. Card and Path bring up their assignment-source typed characteristics via local DiffoExample.Calculations.InheritedCharacteristic, tested end-to-end. JSON rendering of the inherited values is upstreamed to diffo#173, and the DSL declarations themselves to diffo#172 — once both land, the local calc module moves to diffo and the resource declarations become inherited_characteristic macros with no consumer wiring required.