git clone https://github.com/Nasdanika-SDK/roadmap
cd roadmap
mvn verify

public interface Binding<T> extends Supplier<T>, Flow.Publisher<T>, Closeable {

    /**
     * @return true once {@link #close()} was called, or the binding this one follows ended
     */
    boolean isClosed();

}

ValueBinding<String> account = Bindings.value("Checking");

Collector<String> collector = new Collector<>(Long.MAX_VALUE);
account.subscribe(collector); // (1)
account.set("Savings");
account.set("Savings"); // (2)

assertThat(account.get()).isEqualTo("Savings"); // (3)
assertThat(collector.items).containsExactly("Checking", "Savings");

ValueBinding<Integer> progress = Bindings.value(0);

Collector<Integer> frame = new Collector<>(1); // (1)
progress.subscribe(frame);
for (int done = 1; done <= 1000; ++done) {
    progress.set(done); // (2)
}
assertThat(frame.items).containsExactly(0);

frame.subscription.request(1); // (3)
assertThat(frame.items).containsExactly(0, 1000);

private void step() {
    if (done || cancelled) {
        return;
    }
    Throwable error = failure;
    if (error != null) {
        end();
        subscriber.onError(error);
        return;
    }
    if (requested.get() > 0 && dirty.compareAndSet(true, false)) {
        T value;
        try {
            value = Objects.requireNonNull(get(), "A binding's value is never null");
        } catch (RuntimeException e) {
            end();
            subscriber.onError(e);
            return;
        }
        if (!value.equals(last)) { // (1)
            last = value;
            if (requested.get() != Long.MAX_VALUE) {
                requested.decrementAndGet();
            }
            subscriber.onNext(value);
        }
    }
    if (completing && !done && !cancelled) {
        end();
        subscriber.onComplete();
    }
}

Pump pump = new Pump();
ValueBinding<Integer> progress = Bindings.value(0, pump); // (1)

Collector<Integer> collector = new Collector<>(Long.MAX_VALUE);
progress.subscribe(collector);
progress.set(1);
progress.set(2);
progress.set(3);
assertThat(collector.items).isEmpty(); // (2)

pump.settle(); // (3)
assertThat(collector.items).containsExactly(3);

static final ContextKey<String> CONTROL = ContextKey.named("control");

@Test
void aChangeIsDeliveredInTheContextItWasMadeIn() {
    Pump pump = new Pump();
    ValueBinding<String> amount = Bindings.value("0", pump);

    List<String> seen = new ArrayList<>();
    amount.subscribe(each(value -> seen.add(value + " from " + Context.current().get(CONTROL)))); // (1)
    pump.settle();

    try (Scope scope = Context.current().with(CONTROL, "transfer/amount").makeCurrent()) {
        amount.set("100"); // (2)
    }
    pump.settle(); // (3)

    assertThat(seen).containsExactly("0 from null", "100 from transfer/amount");
}

ValueBinding<Integer> cents = Bindings.value(1999);
Binding<String> label = Bindings.map(cents, value -> "$%d.%02d".formatted(value / 100, value % 100));

assertThat(label.get()).isEqualTo("$19.99"); // (1)

Collector<String> collector = new Collector<>(Long.MAX_VALUE);
label.subscribe(collector);
cents.set(2500);
assertThat(collector.items).containsExactly("$19.99", "$25.00"); // (2)

label.close(); // (3)
assertThat(collector.completed).isTrue();
assertThat(cents.isClosed()).isFalse();
assertThat(cents.getSubscriberCount()).isZero();

ValueBinding<Integer> quantity = Bindings.value(2);
ValueBinding<Integer> price = Bindings.value(5);
Binding<Integer> total = Bindings.combine(quantity, price, (q, p) -> q * p);

Collector<Integer> collector = new Collector<>(Long.MAX_VALUE);
total.subscribe(collector);
quantity.set(3);
price.set(10);

assertThat(collector.items).containsExactly(10, 15, 30);

ValueBinding<Integer> celsius = Bindings.value(0);
ValueBinding<Integer> kelvin = Bindings.value(273);
celsius.subscribe(each(value -> kelvin.set(value + 273)));
kelvin.subscribe(each(value -> celsius.set(value - 273))); // (1)

celsius.set(100);
assertThat(kelvin.get()).isEqualTo(373);

kelvin.set(0);
assertThat(celsius.get()).isEqualTo(-273);

EClass account = EcoreFactory.eINSTANCE.createEClass(); // (1)
account.setName("Account");

Binding<Optional<String>> name = Bindings.of(account, EcorePackage.Literals.ENAMED_ELEMENT__NAME, String.class);
Collector<Optional<String>> collector = new Collector<>(Long.MAX_VALUE);
name.subscribe(collector);

account.setName("CheckingAccount"); // (2)
account.setName(null);

assertThat(collector.items).containsExactly(Optional.of("Account"), Optional.of("CheckingAccount"), Optional.empty());

name.close(); // (3)
assertThat(account.eAdapters()).isEmpty();

ValueBinding<String> status = Bindings.value("running");
Collector<String> collector = new Collector<>(Long.MAX_VALUE);
status.subscribe(collector);

status.close();
status.close(); // (1)

assertThat(collector.completed).isTrue();
assertThat(status.get()).isEqualTo("running"); // (2)
assertThatThrownBy(() -> status.set("done")).isInstanceOf(IllegalStateException.class);

Collector<String> late = new Collector<>(Long.MAX_VALUE);
status.subscribe(late); // (3)
assertThat(late.items).containsExactly("running");
assertThat(late.completed).isTrue();

public interface Waypoint<E> {

    /**
     * The element this waypoint records the execution at.
     */
    E getElement();

    /**
     * The waypoints this one was reached from, in creation order: none for a root, one for a step
     * forward, several for a join.
     */
    List<? extends Waypoint<E>> getParents();

    /**
     * A step forward: a waypoint at the next element with this one as its only parent.
     */
    Waypoint<E> commit(E next);

    /**
     * A join: a waypoint at the next element with this one as its first parent and the others after it.
     */
    Waypoint<E> merge(E next, Iterable<? extends Waypoint<E>> additionalParents);
}

Waypoint<String> order = Waypoints.root("order");
Waypoint<String> validate = order.commit("validate"); // (1)
Waypoint<String> price = validate.commit("price"); // (2)
Waypoint<String> stock = validate.commit("stock");
Waypoint<String> ship = price.merge("ship", List.of(stock)); // (3)

assertThat(ship.getParents()).isEqualTo(List.of(price, stock));
assertThat(ship.lineage().map(Waypoint::getElement))
        .containsExactly("ship", "price", "stock", "validate", "order"); // (4)
assertThat(validate.getParents()).isEqualTo(List.of(order)); // (5)

StateWaypoint<String, String> validate = Waypoints.root("order", "received").commit("validate", "valid");
StateWaypoint<String, String> failed = validate.commit("price", "timeout");

StateWaypoint<String, String> retry = validate.commit("price", "priced"); // (1)

assertThat(retry.getParents()).isEqualTo(List.of(validate));
assertThat(failed.getState()).isEqualTo("timeout"); // (2)
assertThat(validate.getState()).isEqualTo("valid");

StateWaypoint<String, String> order = Waypoints.root("order", "3 widgets");
StateWaypoint<String, Integer> price = order.commit("price", 120);
StateWaypoint<String, Boolean> stock = order.commit("stock", true);

StateWaypoint<String, String> ship = price.map(
        "ship",
        joining -> "charge " + joining.get(0).getState() + ", in stock: " + joining.get(1).getState(), // (1)
        List.of(stock));

assertThat(ship.getState()).isEqualTo("charge 120, in stock: true");
assertThat(ship.getParents()).isEqualTo(List.of(price, stock));

static boolean settled(StateWaypoint<String, Integer> waypoint) {
    return waypoint.lineage()
            .skip(1) // (1)
            .filter(earlier -> earlier.getElement().equals(waypoint.getElement()))
            .findFirst() // (2)
            .map(earlier -> earlier.facet(StateWaypoint.class).orElseThrow().getState().equals(waypoint.getState()))
            .orElse(false);
}

@Test
void settlingIsARuleOverLineage() {
    Map<String, String> ring = Map.of("a", "b", "b", "c", "c", "a"); // (3)

    StateWaypoint<String, Integer> waypoint = Waypoints.root("a", 64);
    while (!settled(waypoint)) {
        waypoint = waypoint.commit(ring.get(waypoint.getElement()), waypoint.getState() / 2); // (4)
    }

    assertThat(waypoint.getElement()).isEqualTo("b");
    assertThat(waypoint.getState()).isZero();
    assertThat(waypoint.visits("b")).isEqualTo(4); // (5)
    assertThat(waypoint.lineage()).hasSize(11);
}

public interface Realm<S> {

    /**
     * Runs a command against the guarded state and returns when it completes.
     */
    void execute(Consumer<? super S> command);

    /**
     * Computes a value from the guarded state.
     */
    <T> T apply(Function<? super S, ? extends T> command);

    /**
     * This realm seen as a realm of another state: a lens, not a snapshot. The adapter runs inside
     * this realm on every access, so the view keeps this realm's rules.
     */
    default <T> Realm<T> adapt(Function<? super S, ? extends T> adapter) {
        Realm<S> self = this;
        return new Realm<>() {

            @Override
            public void execute(Consumer<? super T> command) {
                self.execute(state -> command.accept(adapter.apply(state)));
            }

            @Override
            public <R> R apply(Function<? super T, ? extends R> command) {
                return self.apply(state -> command.apply(adapter.apply(state)));
            }

        };
    }

}

static final ContextKey<String> SCREEN = ContextKey.named("screen");

@Test
void aRealmOnAPumpRunsOneCommandAtATimeInTheContextItWasIssuedIn() {
    Pump pump = new Pump();
    List<String> ledger = new ArrayList<>(); // (1)
    PumpRealm<List<String>> realm = Realms.pump(ledger, pump);

    RealmWaypoint<String, List<String>> debit = Waypoints.realm("transfer", realm).commit("debit");
    try (Scope scope = Context.current().with(SCREEN, "transfer").makeCurrent()) {
        debit.execute(entries -> entries.add("debit 100 from " + Context.current().get(SCREEN))); // (2)
    }
    RealmWaypoint<String, List<String>> credit = debit.commit("credit");
    credit.execute(entries -> entries.add("credit 100"));

    int entries = credit.apply(List::size);
    assertThat(entries).isEqualTo(2);
    assertThat(ledger).containsExactly("debit 100 from transfer", "credit 100");

    CompletableFuture<Integer> size = realm.submit(List::size).toCompletableFuture(); // (3)
    assertThat(size).isNotDone();
    pump.settle();
    assertThat(size).isCompletedWithValue(2);
}

try (PublishingTracerProvider provider = new PublishingTracerProvider(TracerProvider.noop())) { // (1)
    Tracer tracer = provider.get("orders");

    StateWaypoint<String, Integer> root = Waypoints.root("order", 0);
    TelemetryWaypoint<String> order = Waypoints.traced(root, tracer, element -> "step " + element); // (2)
    TelemetryWaypoint<String> price = order.follow(root.commit("price", 120)); // (3)
    TelemetryWaypoint<String> stock = order.commit("stock");
    TelemetryWaypoint<String> ship = price.merge("ship", List.of(stock)); // (4)

    PublishingSpan span = (PublishingSpan) ship.getSpan();
    assertThat(span.getName()).isEqualTo("step ship");
    assertThat(span.getParent()).isSameAs(price.getSpan());
    assertThat(span.getParent().getParent()).isSameAs(order.getSpan());
    assertThat(ship.getParents()).isEqualTo(List.of(price, stock));

    assertThat(ship.facet(StateWaypoint.class).orElseThrow().getState()).isEqualTo(120); // (5)
    assertThat(ship.call(Span::current)).isSameAs(span); // (6)

    for (TelemetryWaypoint<String> waypoint: List.of(ship, stock, price, order)) {
        waypoint.close();
    }
    assertThat(span.isEnded()).isTrue();
}

@FunctionalInterface
public interface Widget<R, C> {

    R render(C context);

}

enum Status {

    AVAILABLE(Variant.SUCCESS),
    SKETCH(Variant.WARNING),
    PLANNED(Variant.SECONDARY);

    final Variant variant;

    Status(Variant variant) {
        this.variant = variant;
    }

}

record Item(String name, String module, Status status) {

}

static final List<Item> ITEMS = List.of(
        new Item("Bindings", "runtime/common", Status.SKETCH),
        new Item("Waypoints", "runtime/common", Status.SKETCH),
        new Item("Widgets", "runtime/widget", Status.SKETCH),
        new Item("Terminal on TamboUI", "runtime/tui", Status.SKETCH),
        new Item("Nasdanika Commander", "runtime/commander", Status.SKETCH),
        new Item("Screens drawn in Draw.io", "none yet", Status.PLANNED));

static <C> Widget<?, C> roadmap(Kinds<C> kinds, Supplier<String> runtime, List<Item> items) {
    Text<C> text = kinds.require(Text.class);
    Link<C> link = kinds.require(Link.class);
    Badge<C> badge = kinds.require(Badge.class);
    Section<C> section = kinds.require(Section.class);
    ItemList<C> list = kinds.require(ItemList.class);
    Optional<Table<C>> table = kinds.find(Table.class);

    Widget<?, C> body = table
            .<Widget<?, C>>map(kind -> kind.table(
                    List.of(
                            new Table.Column<Item, C>(text.text("Item"), item -> text.text(item.name()), 4),
                            new Table.Column<Item, C>(text.text("Module"), item -> text.text(item.module()), 3),
                            new Table.Column<Item, C>(text.text("Status"), item -> badge.badge(item.status().name(), item.status().variant), 2)),
                    Table.Rows.of(items)))
            .orElseGet(() -> list.list(false, items.stream().map(item -> text.text(item.name() + ", " + item.status())).toList()));

    return section.section(text.text("Runtime roadmap"), List.of(
            text.text(() -> "Built on runtime " + runtime.get() + "."),
            body,
            link.link(text.text("roadmap.sdk.nasdanika.org"), "https://roadmap.sdk.nasdanika.org")));
}

StringBuilder out = new StringBuilder();
roadmap(Kinds.of(GfmContext.class), RUNTIME, ITEMS).render(new GfmContext(out));

# Runtime roadmap

Built on runtime 2026.11.0.

| Item | Module | Status |
| --- | --- | --- |
| Bindings | runtime/common | **SKETCH** |
| Waypoints | runtime/common | **SKETCH** |
| Widgets | runtime/widget | **SKETCH** |
| Terminal on TamboUI | runtime/tui | **SKETCH** |
| Nasdanika Commander | runtime/commander | **SKETCH** |
| Screens drawn in Draw.io | none yet | **PLANNED** |

[roadmap.sdk.nasdanika.org](<https://roadmap.sdk.nasdanika.org>)

# Runtime roadmap

Built on runtime 2026.11.0.

- Bindings, SKETCH
- Waypoints, SKETCH
- Widgets, SKETCH
- Terminal on TamboUI, SKETCH
- Nasdanika Commander, SKETCH
- Screens drawn in Draw.io, PLANNED

[roadmap.sdk.nasdanika.org](<https://roadmap.sdk.nasdanika.org>)

GridContext screen = new GridContext(64, 12);
roadmap(Kinds.of(TerminalContext.class), RUNTIME, ITEMS).render(screen);

Runtime roadmap
  Built on runtime 2026.11.0.
  Item                       Module               Status
  -------------------------- -------------------- --------------
  Bindings                   runtime/common       SKETCH
  Waypoints                  runtime/common       SKETCH
  Widgets                    runtime/widget       SKETCH
  Terminal on TamboUI        runtime/tui          SKETCH
  Nasdanika Commander        runtime/commander    SKETCH
  Screens drawn in Draw.io   none yet             PLANNED
  roadmap.sdk.nasdanika.org

public record KindOf(Class<?> kind, Class<?> contextType) {

    public KindOf {
        Objects.requireNonNull(kind, "kind");
        Objects.requireNonNull(contextType, "contextType");
    }

}

public class MarkdownKinds extends KindFactory {

    public MarkdownKinds() {
        super(
            new KindProvider<>(Text.class, MarkdownContext.class, new MarkdownText()),
            new KindProvider<>(Link.class, MarkdownContext.class, new MarkdownLink()),
            new KindProvider<>(Section.class, MarkdownContext.class, new MarkdownSection()),
            new KindProvider<>(ItemList.class, MarkdownContext.class, new MarkdownItemList()),
            new KindProvider<>(Badge.class, MarkdownContext.class, new MarkdownBadge()),
            new KindProvider<>(Table.class, GfmContext.class, new GfmTable())); // (1)
    }

provides CapabilityFactory with
    MarkdownKinds,
    TerminalKinds;

Kinds<MarkdownContext> markdown = Kinds.of(MarkdownContext.class);
Kinds<GfmContext> gfm = Kinds.of(GfmContext.class);

Text<MarkdownContext> markdownText = markdown.require(Text.class);
Text<GfmContext> gfmText = gfm.require(Text.class);
assertThat((Object) gfmText).isSameAs(markdownText); // (1)

assertThat(gfm.find(Table.class)).isPresent();
assertThat(markdown.find(Table.class)).isEmpty(); // (2)
assertThatThrownBy(() -> markdown.require(Table.class))
        .isInstanceOf(UnsupportedOperationException.class)
        .hasMessage("No Table for " + MarkdownContext.class.getName());

@SuppressWarnings("unchecked")
public <K> Optional<K> find(Class<? super K> kind) {
    return (Optional<K>) resolved.computeIfAbsent(kind, this::resolve);
}

private Optional<Object> resolve(Class<?> kind) {
    List<KindProvider<?>> providers = loader.loadAll(new KindOf(kind, contextType)); // (1)
    KindProvider<?> best = null;
    for (KindProvider<?> provider: providers) {
        if (best == null || isMoreSpecific(provider, best)) { // (2)
            best = provider;
        } else if (provider.contextType() == best.contextType() && provider.implementation() != best.implementation()) {
            Telemetry.log( // (3)
                    Telemetry.logger(Telemetry.current()),
                    Severity.WARN,
                    "widget.kind.ambiguous",
                    "More than one " + kind.getSimpleName() + " for " + best.contextType().getName() + ", the first one is used",
                    Attributes.empty());
        }
    }
    return Optional.ofNullable(best).map(KindProvider::implementation);
}

private static boolean isMoreSpecific(KindProvider<?> candidate, KindProvider<?> current) {
    return candidate.contextType() != current.contextType() && current.contextType().isAssignableFrom(candidate.contextType());
}

static final Text<GfmContext> SHOUTING = (value, format) -> context -> {
    context.emit(context.escape(value.get().toUpperCase()));
    return null;
};

static final class ShoutingKinds extends KindFactory {

    ShoutingKinds() {
        super(new KindProvider<>(Text.class, GfmContext.class, SHOUTING));
    }

}

@Test
void aKindForAMoreSpecificContextWins() {
    CapabilityLoader loader = CapabilityLoader.of(new MarkdownKinds(), new ShoutingKinds()); // (1)

    Text<GfmContext> gfmText = Kinds.of(GfmContext.class, loader).require(Text.class);
    Text<MarkdownContext> markdownText = Kinds.of(MarkdownContext.class, loader).require(Text.class);

    assertThat((Object) gfmText).isSameAs(SHOUTING); // (2)
    assertThat((Object) markdownText).isNotSameAs(SHOUTING);
}

Text<MarkdownContext> text = Kinds.of(MarkdownContext.class).require(Text.class); // (1)
Widget<?, MarkdownContext> widget = text.text("<script>alert(1)</script> *bold* [x](javascript:alert(1))"); // (2)

StringBuilder out = new StringBuilder();
widget.render(new MarkdownContext(out)); // (3)

assertThat(out.toString()).isEqualTo("\\<script\\>alert(1)\\</script\\> \\*bold\\* \\[x\\](javascript:alert(1))\n\n");

Text<TerminalContext> text = Kinds.of(TerminalContext.class).require(Text.class);
GridContext screen = new GridContext(30, 1);

text.text("x\u001b]8;;http://evil\u0007link").render(screen); // (1)

assertThat(screen.toString()).isEqualTo("x�]8;;http://evil�link\n");

Text<MarkdownContext> text = Kinds.of(MarkdownContext.class).require(Text.class);
List<String> diagnostics = new ArrayList<>();
StringBuilder out = new StringBuilder();
MarkdownContext context = new MarkdownContext(out, 1, MarkdownContext.Mode.BLOCK, (severity, message) -> diagnostics.add(severity + ": " + message));

text.text(() -> "Balance is **overdue**", Text.MARKDOWN).render(context); // (1)
text.text(() -> "Balance is <b>overdue</b>", Text.HTML).render(context); // (2)

assertThat(out.toString()).isEqualTo("Balance is **overdue**\n\nBalance is \\<b\\>overdue\\</b\\>\n\n");
assertThat(diagnostics).containsExactly("WARN: No conversion from html to Markdown, rendered as plain text");

private static final class MarkdownSection implements Section<MarkdownContext> {

    @Override
    public Widget<Void, MarkdownContext> section(Widget<?, ? super MarkdownContext> title, List<? extends Widget<?, ? super MarkdownContext>> body) {
        return context -> {
            if (context.getMode() != Mode.BLOCK) {
                context.diagnostic(Severity.WARN, "A section inside a line or a table cell: only its title is rendered");
                context.emit(render(title, context, context.getMode()));
                return null;
            }
            context.emit("#".repeat(Math.min(context.getLevel(), 6)) + " " + render(title, context, Mode.INLINE));
            MarkdownContext nested = context.nested(); // (1)
            for (Widget<?, ? super MarkdownContext> widget: body) {
                widget.render(nested);
            }
            return null;
        };
    }

}

public MarkdownContext capture(Mode mode) {
    return derive(new StringBuilder(), level, mode, diagnostics);
}

/**
 * @return What was written into a context made by {@link #capture(Mode)}, without the blank lines at its end
 */
public String captured() {
    if (out instanceof StringBuilder buffer) {
        return buffer.toString().stripTrailing();
    }
    throw new IllegalStateException("Not a capturing context");
}

public String escape(String plain) {
    StringBuilder escaped = new StringBuilder(plain.length() + 16);
    boolean lineStart = true;
    for (int i = 0; i < plain.length(); ++i) {
        char ch = plain.charAt(i);
        switch (ch) {
            case '\\', '`', '*', '_', '[', ']', '<', '>', '~' -> escaped.append('\\').append(ch); // (1)
            case '&' -> escaped.append("&amp;");
            case '|' -> escaped.append(mode == Mode.CELL ? "\\|" : "|"); // (2)
            case '#', '+', '-', '=' -> escaped.append(lineStart ? "\\" : "").append(ch); // (3)
            case '.', ')' -> escaped.append(lineStart(plain, i) ? "\\" : "").append(ch); // (4)
            case '\r' -> { }
            case '\n' -> escaped.append(mode == Mode.BLOCK ? "\n" : " "); // (5)
            default -> escaped.append(Character.isISOControl(ch) ? ' ' : ch);
        }
        lineStart = ch == '\n' || (lineStart && ch == ' ');
    }
    return escaped.toString();
}

public interface SurfaceContext extends RenderContext {

    double getWidth();

    double getHeight();

    /**
     * A context for a part of this area, with coordinates relative to this area. The part is clipped
     * to this area: a widget cannot draw outside what it was given.
     */
    SurfaceContext area(double x, double y, double width, double height);

}

public interface TerminalContext extends SurfaceContext {

    @Override
    TerminalContext area(double x, double y, double width, double height);

    default TerminalContext area(int column, int row, int columns, int rows) {
        return area((double) column, (double) row, (double) columns, (double) rows);
    }

    default int getColumns() {
        return (int) getWidth();
    }

    default int getRows() {
        return (int) getHeight();
    }

    /**
     * Writes text on one row, starting at a column, both relative to this area. What does not fit the
     * area is not written, and control characters never reach the terminal.
     */
    void put(int column, int row, String text, TextStyle style);

    /**
     * A context for the same area in which text takes the given style unless it brings its own: how
     * a section makes its title bold without knowing what the title is.
     */
    TerminalContext styled(TextStyle style);

}

private static final class TerminalSection implements Section<TerminalContext> {

    private static final int INDENT = 2;

    @Override
    public Widget<Integer, TerminalContext> section(Widget<?, ? super TerminalContext> title, List<? extends Widget<?, ? super TerminalContext>> body) {
        return context -> {
            int row = rows(title, context.styled(TextStyle.PLAIN.withBold().withVariant(Variant.PRIMARY))); // (1)
            for (Widget<?, ? super TerminalContext> widget: body) {
                TerminalContext area = context.area(INDENT, row, context.getColumns() - INDENT, context.getRows() - row); // (2)
                row += rows(widget, area); // (3)
            }
            return row;
        };
    }

}

ValueBinding<String> asOf = Bindings.value("2026-11-11");
Widget<?, TerminalContext> view = accounts(Kinds.of(TerminalContext.class), asOf, ACCOUNTS); // (1)

GridContext first = new GridContext(44, 3);
view.render(first);
asOf.set("2026-11-12");
GridContext second = new GridContext(44, 3);
view.render(second); // (2)

assertThat(first.toString()).contains("Balances as of 2026-11-11.");
assertThat(second.toString()).contains("Balances as of 2026-11-12.");

public class TamboUIContext implements TerminalContext {

    private final Buffer buffer;
    private final Rect rect;
    private final TextStyle base;

    /**
     * A context for a whole buffer.
     */
    public TamboUIContext(Buffer buffer) {
        this(buffer, buffer.area(), null);
    }

    /**
     * A context for an area of a buffer, as TamboUI passes them to a widget.
     */
    public TamboUIContext(Buffer buffer, Rect rect) {
        this(buffer, rect, null);
    }

    private TamboUIContext(Buffer buffer, Rect rect, TextStyle base) {
        this.buffer = Objects.requireNonNull(buffer, "buffer");
        this.rect = Objects.requireNonNull(rect, "rect");
        this.base = base;
    }

    /** The buffer, for widgets written for TamboUI. */
    public Buffer getBuffer() {
        return buffer;
    }

    /** The area of the buffer this context draws into, in the buffer's coordinates. */
    public Rect getRect() {
        return rect;
    }
    // ...
}

@Override
public void put(int column, int row, String text, TextStyle style) {
    if (row < 0 || row >= rect.height() || column >= rect.width()) {
        return;
    }
    String clean = GridContext.sanitize(text); // (1)
    int from = Math.max(0, -column);
    int to = Math.min(clean.length(), rect.width() - column); // (2)
    if (from < to) {
        buffer.setString(rect.x() + column + from, rect.y() + row, clean.substring(from, to), style(style.over(base)));
    }
}

public static Style style(TextStyle style) {
    Style result = Style.EMPTY;
    if (style.variant() != null) {
        result = result.fg(color(style.variant()));
    }
    if (style.bold()) {
        result = result.bold();
    }
    if (style.underlined()) {
        result = result.underlined();
    }
    if (style.reversed()) {
        result = result.reversed();
    }
    if (style.link() != null && style.link().chars().noneMatch(Character::isISOControl)) { // (1)
        result = result.hyperlink(style.link());
    }
    return result;
}

public static Color color(Variant variant) {
    return switch (variant) {
        case PRIMARY -> Color.LIGHT_BLUE; // Plain blue is too dark to read on a dark background
        case SECONDARY -> Color.GRAY;
        case SUCCESS -> Color.GREEN;
        case DANGER -> Color.RED;
        case WARNING -> Color.YELLOW;
        case INFO -> Color.CYAN;
        case LIGHT -> Color.WHITE;
        case DARK -> Color.DARK_GRAY;
    };
}

Kinds<TamboUIContext> tamboui = Kinds.of(TamboUIContext.class);
Kinds<TerminalContext> terminal = Kinds.of(TerminalContext.class);

Text<TamboUIContext> text = tamboui.require(Text.class);
Text<TerminalContext> neutralText = terminal.require(Text.class);
assertThat((Object) text).isSameAs(neutralText); // (1)

Section<TamboUIContext> section = tamboui.require(Section.class);
Section<TerminalContext> neutralSection = terminal.require(Section.class);
assertThat((Object) section).isNotSameAs(neutralSection); // (2)

private static final class BlockSection implements Section<TamboUIContext> {

    @Override
    public Widget<Integer, TamboUIContext> section(Widget<?, ? super TamboUIContext> title, List<? extends Widget<?, ? super TamboUIContext>> body) {
        return context -> {
            Rect rect = context.getRect();
            if (rect.width() < 6 || rect.height() < 3) {
                return TerminalKinds.rows(title, context);
            }

            // The body, drawn off screen first: its height is the height of the box
            Buffer scratch = Buffer.empty(Rect.of(rect.width() - 4, rect.height() - 2));
            TamboUIContext inner = new TamboUIContext(scratch); // (1)
            int rows = 0;
            for (Widget<?, ? super TamboUIContext> widget: body) {
                rows += TerminalKinds.rows(widget, inner.area(0, rows, inner.getColumns(), inner.getRows() - rows));
            }
            rows = Math.min(rows, rect.height() - 2);

            Block.builder() // (2)
                    .borders(Borders.ALL)
                    .borderType(BorderType.PLAIN)
                    .borderColor(TamboUIContext.color(Variant.SECONDARY))
                    .build()
                    .render(new Rect(rect.x(), rect.y(), rect.width(), rows + 2), context.getBuffer());

            for (int y = 0; y < rows; ++y) {
                for (int x = 0; x < scratch.width(); ++x) {
                    Cell cell = scratch.get(x, y);
                    if (!cell.isEmpty()) {
                        context.getBuffer().set(rect.x() + 2 + x, rect.y() + 1 + y, cell);
                    }
                }
            }

            TamboUIContext heading = context.styled(TextStyle.PLAIN.withBold().withVariant(Variant.PRIMARY)).area(2, 0, rect.width() - 4, 1);
            TerminalKinds.rows(title, heading); // (3)
            return rows + 2;
        };
    }

}

Kinds<TamboUIContext> kinds = Kinds.of(TamboUIContext.class);
Text<TamboUIContext> text = kinds.require(Text.class);
Section<TamboUIContext> section = kinds.require(Section.class);
ItemList<TamboUIContext> list = kinds.require(ItemList.class);

Buffer buffer = Screenshots.draw(30, 6, context -> section.section(
        text.text("Accounts"),
        List.of(list.list(false, List.of(text.text("Checking"), text.text("Savings"))))).render(context));

Buffer buffer = Screenshots.draw(30, 3, context -> context.put(1, 1, "Balance  1,200.00", TextStyle.PLAIN.withBold()));

String svg = Screenshots.svg(buffer, "Accounts"); // (1)
String selfContained = Screenshots.selfContained(svg); // (2)

assertThat(svg).startsWith("<svg").contains("Accounts").contains("@font-face");
assertThat(selfContained).startsWith("<svg").doesNotContain("@font-face").doesNotContain("https://cdnjs");
assertThat(Screenshots.svg(buffer, "Accounts")).isEqualTo(svg); // (3)

Widget<?, TamboUIContext> view = roadmap(Kinds.of(TamboUIContext.class), RUNTIME, ITEMS); // (1)
Buffer buffer = Screenshots.draw(64, 12, view::render); // (2)

Path directory = Path.of(System.getProperty("roadmap.target", "target"), "showcase");
Screenshots.write(buffer, "Nasdanika SDK Roadmap", directory.resolve("roadmap.svg")); // (3)

mvn -q package
java -jar runtime/commander/target/commander-2026.11.0.jar [left directory] [right directory]

public void handle(KeyEvent key) {
    if (key.isRelease()) {
        return;
    }
    try {
        if (dialog != null) {
            dialog(key);
        } else {
            switch (mode) {
                case BROWSE -> browse(key);
                case VIEW -> view(key);
                case EDIT -> edit(key);
            }
        }
    } catch (IOException | RuntimeException e) {
        status = "Error: " + e.getClass().getSimpleName() + (e.getMessage() == null ? "" : ": " + e.getMessage()); // (1)
    }
}