Oregami
Repositories/oxedyne/fe2o3

fe2o3_austenite/src/flow/par.rs

24 operations, oldest first

created by r1870400018:63534, which is this file's identity for as long as the history lasts, whatever it is later renamed to

read the file · who wrote it · compare two states

An operation carries no clock of its own. Each row is therefore dated by the first mark written after it by the same replica, which is one copy of the repository, and that mark is where the command that wrote the operation ended.

+ signed and verified, ? signed by a key this forge does not carry, - unsigned

OperationAuthorWhatWhen
+r1870400018:63534replica 1870400018created fe2o3_austenite/src/flow/par.rs49 days ago under "fe2o3_austenite: Type::ALL carries a banner comment, not a doc comment on a constant (O4)"
+r1870400018:63535replica 1870400018inserted 10.2 KiB49 days ago under "fe2o3_austenite: Type::ALL carries a banner comment, not a doc comment on a constant (O4)"
+r1870400018:72675replica 1870400018inserted 31 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72676replica 1870400018inserted 11 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72677replica 1870400018replaced 9 bytes with 35 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72678replica 1870400018replaced 1 byte with 165 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72681replica 1870400018inserted 4 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72683replica 1870400018inserted 4 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72685replica 1870400018inserted 4 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72686replica 1870400018replaced 49 bytes with 70 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72687replica 1870400018inserted 3.1 KiB40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72688replica 1870400018inserted 201 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:72690replica 1870400018replaced 44 bytes with 783 bytes40 days ago under "fe2o3_austenite: the paragraph memo keeps where each line breaks (U9, option b) -- layout_with looks a text-like paragraph up under a key of the caches' configuration, its Config (Config::fingerprint names every field), the region's width and each child's Pair fingerprint; a hit prepares the paragraph afresh (tags, spans, warnings and reads from the current source) and rebuilds each line with line() from its kept (end, Breakpoint), so only the search for the breaks is skipped and a hit makes a miss's boxes. linebreak returns the breaks beside the lines (simple and optimised) and rebuild() builds them again. ParMemo is a Caches field on a generation-swept GenMap under Budgets.pars (16 MiB, about 24 B a line); begin sets the ceiling, end sweeps, clear empties; a budget of 0 makes no key. keepable() admits only Tag, Space, Text, Symbol, H, Linebreak and SmartQuote children: a paragraph with an inline box or equation is laid afresh every compile (U10 lifts this). Every paragraph laid counts par_hits or par_misses. tests/parmemo.rs 14 (key fields, budget, tag spans, warning on a hit, hit equals miss across hyphen, mandatory, RTL and first fit); eval_session and eval_door counters updated. Plant: the width left out of the key turns two parmemo tests red. Hit equals miss byte for byte on syn300 and the Invitation (3efaba66). Hematite Recompiling describes the memo (M2, D-20261011-29)"
+r1870400018:73586replica 1870400018inserted 7 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73587replica 1870400018inserted 101 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73588replica 1870400018replaced 118 bytes with 233 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73589replica 1870400018inserted 4 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73591replica 1870400018inserted 12 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73592replica 1870400018inserted 204 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73593replica 1870400018replaced 1 byte with 2 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73594replica 1870400018replaced 2 bytes with 1 byte40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73595replica 1870400018replaced 4 bytes with 74 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73596replica 1870400018replaced 32 bytes with 55 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"
+r1870400018:73597replica 1870400018inserted 276 bytes40 days ago under "fe2o3_austenite flow: the paragraph memo keeps paragraphs holding an inline box or equation (U10) -- `ReadLog::asks` counts every question put to the introspector, a repeat included, which the log of distinct reads does not grow for (U9 hazard 1); it is bumped in `note` and at the count-before read in `stop_at`. `keepable` returns `Keep { No, Width, Region }`: a Box or Equation child gives Region, whose key adds the region's height, base and expansion, which laying those out reads, while a paragraph of text keeps the width-only key. `layout_with` drops the key when the ask count moved across `prepare`, so a box reading `context` is neither taken from the memo nor stored in it, though a paragraph in its body that asks nothing is. A hit still prepares, so boxes, equations, tags and warnings come from the current source and only the break search is saved. On the 300-page inline-maths book a one-letter edit's misses fall from 1,200 to 1 and the keystroke from 0.664 s to 0.307 s natively (medians of 12, 4 alternating rounds, load 3.5-5.3); the cold compile from 3.66 s to 3.30 s. Tests in parmemo: box, framed box, equation and both kept, hit = miss = cold to the bit; a warning from the paragraph and from inside a box raised again on a hit; height alone and base alone each change the key (planted: height out of the key turns it red); a box asking the introspector never kept, even repeating its question; the ask count grows for a repeat; in a session the box and equation paragraphs hit, an edit misses one, and warm bytes equal cold with the memo on and off, also after an edit above changes what a box's `context` reads"