vega/surfaces/main.c, branch masterSurface runtime projecting Pure views across pixel, terminal, CLI, and web.
http://git.yeowoo.org/vega/atom?h=master2026-10-18T22:54:06ZSize to the module what is the module's (Pure 027's 4f-3a): timers grow to its inputs, the focus marks to its views, the accessibility tree's children to their count; a table shows its first VEGA_COLUMNS (64) columns, Vega's own count2026-10-18T22:54:06Zeunhhunecpition205@gmail.com2026-10-18T22:54:06Zurn:sha1:a2ad1a7a9cd3e608f3fb4e5a694540a9cfef9c69Send every input as a message (Pure 027's 4d): keys, text, timers, frames and pointing go to the inputs bound to them; a key's press then its release when a message takes it; vega_frame sends dt 1/60 to the frame input, deferring the save as frames were; a table's pointer is the input pointing at it, sent the item's position; a key's handler found by its input's number2026-10-18T19:54:17Zeunhhunecpition205@gmail.com2026-10-18T19:54:17Zurn:sha1:4d9598e7d0d6d45bf3db9305d365bd2967481bcdSay why Pure refused to start or replace the module2026-09-30T04:38:45Zeunhhunecpition205@gmail.com2026-09-30T04:38:45Zurn:sha1:7705831ebdf94186d1513f3e1b8d7d5ab8b3a2c0
pure_app_start and pure_app_replace now say in PureApp.why why they
refused, when they can (sends waiting on an output the module lacks).
Vega printed only the result's number; it prints the reason beside it.
Keep a key cut across the terminal's reads until it comes whole2026-09-29T17:12:28Zeunhhunecpition205@gmail.com2026-09-29T17:12:28Zurn:sha1:461714a01549841746b721d38441df21f74a4077
handle_input found escape sequences only whole within one read, so an
arrow whose ESC [ came in one read and its A in the next was Escape, [
and A (Pure's review 004, F5); a UTF-8 character cut the same way went
in pieces. A read's bytes are not the terminal's keys: now an escape
sequence, a mouse report or a character cut short waits for the next
read. An escape alone that nothing follows within 100 ms (vim's
ttimeoutlen) is the Escape key; the rest of a key already begun waits up
to a second.
check.py's interactive runs a third session with every key coming a
byte at a time, 50 ms apart, and the arrow's A 150 ms after its ESC [:
the focus moves, as when keys come whole; Vega before this marks the
wrong task done.
Wait for timers on the monotonic clock; events still see the wall clock2026-09-29T17:12:23Zeunhhunecpition205@gmail.com2026-09-29T17:12:23Zurn:sha1:c919b5f81ad6cad55935fa7a22bfda9539dd584f
The terminal, the pixel surfaces and the web page reckoned when a timer
was due on the wall clock: set back, a timer waited until the clock came
again to the tick it had waited for (Pure's review 004). vega_clock is
the monotonic clock; timers are due on it, and a tick sets the time its
event sees from the wall clock (vega_now), as before.
check.py's clock_set_back runs a timer of 20 ms in the terminal with the
wall clock set back an hour 0.2 s in (Pure's build/clock-back.so, an
LD_PRELOAD of clock_gettime): 40 ticks in 0.8 s, where Vega before this
stops at 9. make check passes it --clock-back.
Set type on the pixel surfaces: the grid lays out, the fonts shape2026-09-28T14:52:35Zeunhhunecpition205@gmail.com2026-09-28T14:52:35Zurn:sha1:0b554f2ea62a921e1c8a43ffb24ad75f428af2d6
vega_draw keeps what it wrote as spans (VegaSpan: a row, the columns it
was given, where its cells reached, its text and tone). A span written
where the same pen stopped follows the one before it (a field's name and
value, the help line, the prompt); one written after the pen moved (a
table's column, a list's label, a badge) starts afresh at its column, and
a badge sits flush with its end.
When the first font shapes, the pixels set type: a span and those
following it are one line of text, laid out as one paragraph in the font
stack (bidi and kerning cross the spans; each glyph takes the tone of the
span its character came from), from its column up to the nearest of its
spans' ends and the next span on the row, cut at a grapheme cluster
boundary with an ellipsis if it must be. The prompt gets a text cursor.
--symbols repeats: fonts in order of preference (at most 8); the cells,
when the first font does not shape, also fall back through them.
The check sets a label in one script, alone in its list, and holds it to
what the font that has it sets by itself (vega-symbols paragraph, which
now sizes itself to its text with width 0), pixel for pixel: Latin
kerning, Hangul, Arabic and Devanagari over DejaVu Sans, Noto Sans CJK KR
and FreeSans.
Speak AT-SPI2 on the accessibility bus from the display, over Vega's own D-Bus2026-09-28T12:25:21Zeunhhunecpition205@gmail.com2026-09-28T12:25:21Zurn:sha1:6052b048467f392f4eb9fb5b268cae15e94691d5
vega display --access joins the accessibility bus as AT-SPI2 objects for
screen readers such as Orca, with no toolkit, ATK or libdbus: dbus.c
speaks the D-Bus wire format (EXTERNAL authentication, headers, aligned
bodies, calls, replies, signals). The tree follows what the say surface
says: a heading, a label per field, a list box per list whose items know
their place and which is selected and focused, tables, the entry, the
keys as buttons; answers come from the app when asked, one object has the
focus, and focus moves are said as events. Assistive technology can act
too: Selection focuses a row, Action presses a key. The live loop now
draws only when something changed, so a screen reader's questions no
longer cost frames. The check walks the tree with gdbus on a private
session bus with at-spi-bus-launcher, and follows the focus through keys,
Selection, Action and the events.
Type Hangul on the keyboard (두벌식)2026-09-27T19:03:30Zeunhhunecpition205@gmail.com2026-09-27T19:03:30Zurn:sha1:7b93a66dbffaf2b20b0a1925786f56db54066c9b
Surfaces that read keys (the display, through evdev) had only a US
layout's letters. After the 한/영 key (Lang1, or AltRight standing for
it), letter keys now give jamo that compose syllables in the entry line
(surfaces/hangul.c): an initial, a vowel and an optional final, joined
vowels and finals, a final that moves on to a vowel after it (도깨비불),
Shift's doubled consonants, a lone jamo as its compatibility letter. The
syllable being composed shows after the entry line; Backspace takes it
back a jamo at a time before deleting what was typed; Enter, Tab, the
toggle or any key but a letter finishes it. The script language gains
hangul, letters HEX and back to drive it.
The check types ten cases through it (안녕하세요, 값을, 안자, 와원, 까원,
갑 after Backspace, 한글, ㅏ, 안ㅈ, 안녕 2) and follows the composing line
jamo by jamo; the messenger check has Alice type 안녕 on her display with
recorded keys, drawn on Bob's.
Draw a node's frames into files, and follow its saves after a recording2026-09-27T18:42:23Zeunhhunecpition205@gmail.com2026-09-27T18:42:23Zurn:sha1:a3c24ecbc00b04eaf191f8e16b8e53db57b4caeb
Vega in a node takes a second form, pixels --grid WxH --out PREFIX: each
frame the node's saves draw goes into PREFIX-N.ppm, no display
controller needed (one card takes one master, so a second node on the
machine draws this way). And in a node, recorded events no longer end
the surface: their last frame is printed when they end, and the node's
saves are drawn on until it stops, so an answer that comes later shows.
Show a Pure node's app on its display, as a surface in the node2026-09-27T18:37:33Zeunhhunecpition205@gmail.com2026-09-27T18:37:33Zurn:sha1:5fe8104744d3e0a48674b1368db6fd104a10bdd4
The vega host builds a second way, as build/vega-surface.so, which
pure-serve maps and runs beside its connection threads (pure-serve
--surface vega-surface.so -- display ..., Pure's design 010). There the
app it draws is a reader of the node's last save, read where it is,
and what people type goes to the node's owner: a key press as the key
input's event, the typed line as the text input's, each applied and
saved with the node's requests. It waits on its input devices and the
node's changes descriptor together, leaves timers and signals to the
node, and stops with it. The library calls the app model pure-serve
exports and links none of its own; it exports pure_surface_run alone.
Without --live or --input it takes no input: the node's saves alone draw
it.
The check gives a node an item over HTTP, then runs the display in the
node with recorded keys (an item, Enter, Tab, Space): the last frame is
the one vega tui draws for the same state and keys, it came back from
the display controller as drawn, and the node's views show both items.