pure/docs/design/029-past-one-node.md, branch masterVerified execution runtime unifying state, persistence, and replication.
http://git.yeowoo.org/pure/atom?h=master2026-10-19T13:48:47Z029, 030: 047 written into 029 (the leaf as the commit: appends pass, sparse updates break, two units as said beforehand; packets as 32-row column chunks 1,318 to 44 a row); 030 the one execution path, settled but for one choice: border reading rows where the payload has them, the handler emitted with registers, typed event buffers, shared captures and whole numbers, stored lists read in their leaves (a keyed seek by the guides' keys: 813 a point end to end, cycles 348, nothing copied out), commits writing appends into the leaf's tail and sparse updates to the log, replication as 046; what goes (the executor as a path, the batch lanes, the AArch64 layer, pure_list_read each message, the 54-state walks, the generic list API on hot paths, the bytes piece tree for whole sets); the verifier's three facts (N1, N4 new; N2 widened); representation choices; the user's choice (system cc at install, or Pure's own emitter per instruction set); the order, representation first inside the executor, each step with its check2026-10-19T13:48:47Zeunhhunecpition205@gmail.com2026-10-19T13:48:47Zurn:sha1:0f8c2ec7f98ed34f5567a168147737442d93f9fc029: two framings in the 009 section made plain: there is no disk leaf for a list today (090's tree is in memory, a list on disk is images and a log), so the zero copy measured is memory's; and the seek rung is another program, not an emission (it halves by the tree's order, charges the budget once a call): 578 holds only with a keyed list, its seek and the order, an emitter alone gets 1,576; cycles beside instructions (388 against 312, end to end 368 against 292)2026-10-19T13:26:11Zeunhhunecpition205@gmail.com2026-10-19T13:26:11Zurn:sha1:cf3a1d66c2af6146d895065fa65d132191d48e00029: feedback 009's rule (one byte shape for the same data) applied to both principles' results: packet to execution with no decoding holds in the hand-written border (rows read where the payload has them; checks stay), not in the runtime (a tree each message); the leaf as the execution array with no copy costs nothing only when the search follows the tree's order (578 against the copy's 564; a positional halving descends each probe: 1,576 and 2,114), which needs ranges ordered by start (a keyed list would say it; the app's own halving rebuilds the index the tree is); commit extent = replication record = follower bytes holds as files (046), but an item has more than one shape there: packet = TREE leaf column = image body for one field, the log re-frames each change (64 B a message, 56 of them frame), several fields go by rows in packets and images and by columns in leaves, FLAT event lists narrow; the next question put, not built: the leaf as the commit2026-10-19T13:24:19Zeunhhunecpition205@gmail.com2026-10-19T13:24:19Zurn:sha1:53a2f39429c3c0f3766ee9dc2fb6161bc3619954046, 029: the taken-over store sent a message too (opened() works on a copy: show, add, show; 20 more kill -9s: all open and take it as owners; 667 prefixes again with it: all pass); the price measured again without the fold that inflated it (entries.aup's summed view folded every entry each message): 48.5 to 232 us a message on tmpfs, 146 us of the 183 waiting for acks; the shim never stopped across the runs2026-10-19T13:16:33Zeunhhunecpition205@gmail.com2026-10-19T13:16:33Zurn:sha1:d5107e9e61d1083f945edb64ec619c333024a43f029: principle 2 passed its breaking experiment (046), written with what it showed against its own words: identity (233 samples and the ends of 100,000 and 200,000 messages: 0 bytes differ), taking over (70 kill -9s, all open with every message done), torn tails (867 op boundaries opened, 568 within cuts); "every write a save makes is a self-delimiting, self-verifying extent" false as written (zeros ahead, installs by rename under process-numbered names, directory syncs, 8 MB segments taken): file operations shipped, still no replication layer (the store's own ops cut at its own syncs, heard the ack); the price on tmpfs (204 to 400 us, 903 B a message, 42% zeros the follower could make); what was not tried (a follower started again and heard from its files, pure-serve's checkpoint thread, a real medium and two machines, a segment let go, asynchronous, choosing the owner)2026-10-19T13:10:10Zeunhhunecpition205@gmail.com2026-10-19T13:10:10Zurn:sha1:109c3afd29b6cad3e529d83fde8aeb1d0da700ff045, 029: a message end to end, the event's border written by hand too (app.c's BORDER: rows whole and finite, the budget and memory begun again, the one state the handler changes written apart and made the state's at a faultless end into a buffer no reader holds, events and changes counted; every end answers all 18,672 lines, the broken-rule build refused at both hand ends): machine instructions a code point, the runtime 40,365, its empty handler 1,595, the hand border with shared 592 and with plain 379, Vega's C given the same payload 240: 68x, 2.5x C (cycles 3.2x), the border 1,595 to about 22; what went: the rows rebuilt into a tree each message (pure_list_read's make_tree), 54 states walked five times an event (40 of them t.X's registers), the last event's nested lists, a bytes state set whole through a text's piece tree; no new fact (N2, today's proof, the language, forms chosen)2026-10-19T12:41:28Zeunhhunecpition205@gmail.com2026-10-19T12:41:28Zurn:sha1:de1d30da1203cae9cd857052c339ac026f18cffa029: the facts counted again: two new (N1 whole numbers, N4 unchanged after LIST_VALUE) and one analysis widened (N2 the handler's changes), not three new as 7ffb114 says: the 9.43x of the event's lists as typed buffers needs no new fact (keyed and indexed are declared, an event's list is one by its place; a typed buffer does every operation an unkeyed, unindexed one gets), only the form chosen and the memory charge's contract; seven fns (range and six), not six2026-10-19T12:10:36Zeunhhunecpition205@gmail.com2026-10-19T12:10:36Zurn:sha1:47d81d85ae059d0c949d5c95214e009889421bd1029: UAX #14's whole chain and the facts it needs: the handler 38,623 machine instructions a point (event aside) to 564 emitted by hand, 2.5x Vega's C (225; cycles 3.6x), factors 1.46 (dispatch), 3.02 (memory slots and calls), 1.10 (whole numbers), 1.22 (ranges flat), 9.43 (the event's lists typed buffers), 1.23 (Text sharing), the contract left (bounds 1.12, budget and memory 1.39) and the algorithm (1.61); the facts: today's proof licenses exact (each fn's registers, lists and changes: none of the six has lists or changes), then three new (N1 whole numbers, N3 a let list's operations, N4 unchanged after LIST_VALUE) and one analysis widened (N2 the handler's changes); the event itself now the largest layer (1,566 a point: the points decoded into a list, lists cleared and freed, malloc, breaks through the store tree), outside this chain; a premise corrected (the event's lists are FLAT arrays since 021, not trees: the 9.43x is the generic list path); the let lists' factor, broken by a share before, measured as the chain's largest2026-10-19T12:06:52Zeunhhunecpition205@gmail.com2026-10-19T12:06:52Zurn:sha1:7ffb1145aa11b8c3a691695b3103ee8ae209adc7029: range()'s chain written, and two of its own claims taken back: the executor 14,488 machine instructions a point, stitched 8,144, emitted exact 2,474, with integers 1,587, a flat column 1,083, both 226, C 129 (dispatch 1.78x, memory slots and the call's machinery 3.29x, the numbers' and lists' form 10.9x, bounds and budget 1.75x C); the bar set before (3x C's round) missed by exact (217) and passed by both (19.8); the premises checked: an unchanged list proven (function_changes), a whole-number index not (number slots, INDEX_AT checks it: a fact for the proof to take on), a local's lifetime not tested here; "no layer holds most, each 1.4-1.5x" and the let lists' "broken by arithmetic" were shares inside the executor, not factors; "one machine instruction an instruction is 2.5x C" was wrong (both does 269.5 in 226); what is bundled (memory slots with the call), the flat column's cost moved to changes (unmeasured), and 36% of the app only2026-10-19T11:29:51Zeunhhunecpition205@gmail.com2026-10-19T11:29:51Zurn:sha1:cda1f523dd78c19b6ab770c4b052a9998396346d045: Pure's answers checked for real (cost.c and where.c compared only the C's with the test before; now Pure's boundaries are read from its view, and a wrong variant is refused with 0 lines right); the executor and the stitched build, rebuilt at adccf58, both answer all 18,672 lines, and the stitched build's numbers stand (40,189 to 28,089 machine instructions a point, 1.43x; cycles 1.32x); 029 says so2026-10-19T11:22:24Zeunhhunecpition205@gmail.com2026-10-19T11:22:24Zurn:sha1:41f66b0ea63c9a75a872727ad2a22d2f22688869