keep

Bindary removes its own attributes from an element once it has discovered them. Set b-keep to true and they stay, which is what you need if you intend to change them later.

Why they are removed

Once an element has been discovered, Bindary holds its binding in an internal template item and no longer reads the markup. The attributes have done their job and leaving them behind means the DOM carries instructions nobody follows. Removing them keeps the rendered document clean, which also matters if you inspect it or serialise it.

$bindary.keepAttributes sets this for the whole page. The attribute overrides it for one element and everything below it.

When you need them

Keep the attributes when something other than Bindary needs to read the binding off the element or when the element will be copied, moved or regenerated somewhere Bindary has not already discovered it. In those cases the markup has to stay the source of truth, because the template item only describes the original.

Cloning. An element you cloneNode and insert elsewhere carries no binding if the attributes were stripped, because Bindary discovered the original rather than the copy.
Markup that round-trips. Builder interfaces, export and print views, anything that reads rendered elements to produce new markup. The binding has to survive the round trip.
Rewriting a binding at runtime. Changing which data-key an element points at, rather than changing the data behind it. See the example below.
Debugging. With attributes stripped, inspecting an element tells you nothing about what it is bound to. Turning $bindary.keepAttributes on while diagnosing is a legitimate use.

The option exists at all because Bindary reads the DOM at runtime rather than compiling templates away. A framework with a compile step has no attributes left to keep; here they can remain a live source of truth if you want them to be.

Effect on updates

The setting changes how $bindary.updateTemplateItem() behaves, because it decides where the truth about an element's binding lives.

Attributes removed. The template item is the record. Updating it changes the attributes you specify and leaves the rest as they were. Clear one by passing null.
Attributes kept. The markup is the record. Updating re-reads the element, so any attribute no longer present is cleared.

The second is what you want when the element's binding is genuinely being rewritten, since you can set the attributes and let Bindary work out the rest.

Example

Two elements bound to two different colours. The handler swaps their binding attributes and asks Bindary to re-read both, which it can only do because the attributes are still there.

<div b-context="demo.keep">
    <label>
        <input type="checkbox" b-on-change="$bindary.controller.swapColors" /> swap colors?
    </label>
    <div id="colorA" class="demo-swatch" b-keep="true" b-value="color1"
        b-attributes="style = color: {{color1}};"></div>
    <div id="colorB" class="demo-swatch" b-keep="true" b-value="color2"
        b-attributes="style = color: {{color2}};"></div>
</div>

$bindary.appData.demo.keep = { color1: "Red", color2: "Orange" };

ctrl.swapColors = () =>
{
    let valueAttr = 'b-value',
        attrAttr = 'b-attributes',
        a = $('#colorA'), b = $('#colorB'),
        value = a.getAttribute(valueAttr),
        attr = a.getAttribute(attrAttr);

    a.setAttribute(valueAttr, b.getAttribute(valueAttr));
    a.setAttribute(attrAttr, b.getAttribute(attrAttr));
    b.setAttribute(valueAttr, value);
    b.setAttribute(attrAttr, attr);

    [a, b].forEach($bindary.updateTemplateItem);
    $bindary.updateView(true);
};

Result

swap colors?

This is the third case above: what changes is not the data but which key each element points at. Swapping attributes and re-reading them is only possible because they are still on the element.