Each line, and 2. A List field's generated method has already stepped into the elements, so the path is a TraversalPath<Order, LineItem>. There are two lines; the four bulbs are one line with a quantity of 4.

Where this lives: Find your field.

Declare an OpticsSpec interface for JsonNode, annotated @ImportOptics. The processor reads the spec and generates JsonNodeOptics, with one prism per method, which compose with the rest of your optics:

@ImportOptics
public interface JsonNodeOpticsSpec extends OpticsSpec<JsonNode> {

  @InstanceOf(ObjectNode.class)
  Prism<JsonNode, ObjectNode> object();

  @InstanceOf(ArrayNode.class)
  Prism<JsonNode, ArrayNode> array();

  @InstanceOf(StringNode.class)
  Prism<JsonNode, StringNode> text();

  @InstanceOf(NumericNode.class)
  Prism<JsonNode, NumericNode> numeric();

  @InstanceOf(BooleanNode.class)
  Prism<JsonNode, BooleanNode> bool();
}

Where this lives: Annotating types you don't own.

No: it does not compile, with no suitable method found for combine. parseIfPresent makes a FallibleEdit, and Edits.combine takes only edits that cannot fail, so a failure can never be dropped silently. Put both edits in Edits.accumulate instead.

Where this lives: How the split stays compile-time safe.

A FocusPath to the whole map; .atKey("LAMP") gives an AffinePath to one price. A Map field is not stepped into by default, so its path still focuses the map, and .atKey picks one value, which may be absent.

Where this lives: Access by index.

No. map on a Validated changes only a Valid, and an Invalid passes through untouched, so the result is Invalid with every bad price, and nothing is discounted.

Where this lives: Take an order in.

Only legacyNote. A recognised @Nullable makes the generated method return an AffinePath already. An unannotated reference gives a FocusPath, and .nullable() reads a null as absent.

Where this lives: .nullable(): read a null as absent.

Two, in edit order: the SKU's, then the price's, each located by its path. accumulate checks every edit on its own before it writes anything:

    Validated<NonEmptyList<FieldError>, LineItem> patched =
        Edits.accumulate(
                parseIfPresent(SKU, badPatch.sku(), Sku::parse),
                modifyIfPresent(QUANTITY, badPatch.qtyDelta(), (delta, qty) -> qty + delta),
                parseIfPresent(PRICE, badPatch.price(), Price::parse))
            .apply(line);
    // Invalid(NonEmptyList[sku: not a SKU, price: not a price])
    //   <- or Valid(line) with only the present fields changed

Where this lives: Validated PATCH.

Traversal<Order, BigDecimal>. Many followed by exactly one is still many:

    Traversal<Order, BigDecimal> prices = OrderTraversals.lines().andThen(LineItemLenses.price());

Where this lives: Composing optics with andThen.

No: reading back gives ada@example.com, not what was set. A lens promises that you read back what you set, and the constructor changes the value on the way in, so hkj-test's LensLaws reports the broken law:

    Lens<NormalisedEmail, String> value =
        Lens.of(NormalisedEmail::value, (_, newValue) -> new NormalisedEmail(newValue));

Where this lives: What a lens is, and Use Manual Lens Creation When on checking a hand-written lens.

A traversal into the lines, then the quantity, then setAll:

    Order oneOfEach = OrderFocus.lines().via(LineItemFocus.quantity()).setAll(1, order);

Where this lives: TraversalPath: Zero or More Elements.

A check that returns its verdict, run through the quantities with modifyAllValidated:

  static Validated<String, Integer> checkQuantity(Integer quantity) {
    return quantity >= 1 ? Validated.valid(quantity) : Validated.invalid("No items: " + quantity);
  }

  static Validated<List<String>, Order> acceptQuantities(Order order) {
    return OpticOps.modifyAllValidated(
        order,
        OrderFocus.lines().via(LineItemFocus.quantity()).toTraversal(),
        SelfCheckBook::checkQuantity);
  }

Quantities of 0, 4 and -1 give Invalid(["No items: 0", "No items: -1"]).

Where this lives: Every element, every error.

A path through the state's returned() prism, then modify, which changes only the variant the prism matches:

    Consignment tidied =
        ConsignmentFocus.state()
            .via(ConsignmentStatePrisms.returned())
            .modify(
                returned ->
                    new ConsignmentState.Returned(returned.reason().toUpperCase(Locale.ROOT)),
                consignment);

Where this lives: One variant of a sealed type.