Skip to content

Commit 772766a

Browse files
authored
ledger: cheaper closed-trade history reads and fewer scratch writes per closed trade (#648)
A script that scans closedtrades.entry_id(i) over every closed trade each bar, and a streaming run that publishes and retires rows, paid for four things in v1.9.0 that v1.6.3 never did: - two calls into the engine and a library comparison per visit: add TradeLedger::{entry_id,exit_id,entry_comment,exit_comment}_matches (range check and compare in one call; the old symbols stay), route the four BacktestEngine::closed_trade_*_equals wrappers through them, compare texts of up to eight bytes as two words, keep the entry-id length in the cache entry's generation word so that compare never reads the record line, and prefetch the next cache slots of a sequential scan; - a read cache that doubled with the population and discarded every entry at each doubling, so a script reading the whole history reloaded every row from disk after each growth (about 195,000 preads for 35,000 trades): keep the slot mapping fixed (global modulo cache_rows) and allocate the storage in 256-slot pages behind a page table; the last page is clipped to the cap, retirement frees pages outside the retained window, and the cache holds one page, about 62 KB more, for a non-retiring run of 64 rows or fewer, and up to three pages, about 240 KB, while a retiring run's retained window crosses page boundaries (a fixed amount, independent of the number of trades); - duplicate descriptor writes: the host close-cause pass wrote every row back even when the cause did not change, and the stored record was rewritten when it equalled the new one byte for byte; write back only on a change (a row below the sealed base still goes through replace for its refusal), skip the identical descriptor store, and fill the cache slot of an appended or replaced row from the Trade in memory when a reader already created the cache; - per-text payload writes: the texts of one appended row go out as one contiguous write (same bytes, extents and resident tail), and retirement no longer zeroes on disk the part of a retired text that the same operation's head release zeroes or truncates again. resident_cache_bytes(rows) now includes the page table (ceil(rows / 256) pointers, 2,048 bytes at the default cap); the actual allocation never exceeds it. Skipping duplicate writes also lowers the byte-keyed fdatasync count (the write budget syncs every 64 KiB of successful bytes); durability per byte is unchanged. Reports are byte-identical. Source gate: one new named site, the page allocation in State::ensure_cache_entry (manifest entry U1623, ceilings.unreviewed 1338 -> 1339, the OPEN pin in test_cr150_source_gate 1522 -> 1523); the page table allocation re-uses the reviewed cache entry with its identity refreshed. Three doc anchors that cite engine_orders.cpp lines are re-pinned. docs: memory page: the ledger read cache is paged, not doubled The read-cache row of the memory page described the doubling cache. Rewrite it for the paged cache with a fixed slot mapping and the charge that includes the page table. This removes three sentences of the old row on purpose: - "Direct-mapped, allocated at the first read at the smaller of the cap and the next power of two" (introduced by a991b4e): the cache is now allocated in 256-slot pages behind a page table and never discards entries on growth; - "The declared bound is resident_cache_bytes(kSinkCacheRows): 65,536 x 312 = 20,447,232 B" (introduced by 1654497): the charge now adds the page table, ceil(cap / 256) pointers, 2,048 bytes at the default cap; - "Chosen by the engine, not settable from the C API; cache allocation grows lazily up to the declared constant cap" (introduced by 1654497): the first read creates the page table and each first-touched page allocates its slots; the cap is unchanged and still not settable from the C API. tests: the new test rows are registered through the repository's lane files and fences, and the selected-metrics expectations for the ledger cache bytes are derived from the accounting formula (the page table term included) instead of the old constant. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
1 parent 1065942 commit 772766a

25 files changed

Lines changed: 2871 additions & 144 deletions

‎ci/cr150-source-bounds.yaml‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -74,7 +74,7 @@ scan:
7474
generated_files:
7575
- "tutorial/**/generated*.cpp"
7676
ceilings:
77-
unreviewed: 1338
77+
unreviewed: 1339
7878
pending-flat-memory: 184
7979
owners:
8080
- {name: "generated-cpp", globs: ["tutorial/**"]}
@@ -1363,11 +1363,12 @@ entries:
13631363
- {id: "U1322", file: "src/command_scratch_production.cpp", symbol: "set_command_scratch_byte_cap", ops: ["alloc"], container: "unresolved by the index: make_shared", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 368}
13641364
- {id: "U1323", file: "src/engine_metrics.cpp", symbol: "state_", ops: ["alloc", "assign"], container: "unresolved by the index: make_unique", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 349}
13651365
- {id: "U1324", file: "src/engine_orders.cpp", symbol: "<temp:string>", ops: ["temp"], container: "unresolved by the index: std::string", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 513}
1366-
- {id: "U1325", file: "src/engine_orders.cpp", symbol: "cache", ops: ["alloc"], container: "unresolved by the index: make_unique", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 459}
1366+
- {id: "U1325", file: "src/engine_orders.cpp", symbol: "cache", ops: ["alloc"], container: "unresolved by the index: make_unique", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 470}
13671367
- {id: "U1326", file: "src/engine_orders.cpp", symbol: "directory", ops: ["assign", "decl"], container: "std::string", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 381}
13681368
- {id: "U1327", file: "src/engine_orders.cpp", symbol: "get_string", ops: ["decl"], container: "std::string", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 576}
13691369
- {id: "U1328", file: "src/engine_orders.cpp", symbol: "materialized", ops: ["decl", "grow"], container: "std::map<size_type, Trade>", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 382}
13701370
- {id: "U1329", file: "src/engine_orders.cpp", symbol: "next", ops: ["alloc"], container: "unresolved by the index: make_unique", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 781}
1371+
- {id: "U1623", file: "src/engine_orders.cpp", symbol: "page", ops: ["alloc"], container: "unresolved by the index: make_unique", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 477}
13711372
- {id: "U1330", file: "src/engine_orders.cpp", symbol: "result", ops: ["decl"], container: "std::string", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 578}
13721373
- {id: "U1331", file: "src/engine_orders.cpp", symbol: "state_", ops: ["alloc"], container: "unresolved by the index: make_unique", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 734}
13731374
- {id: "U1332", file: "src/engine_orders.cpp", symbol: "string_field", ops: ["decl"], container: "std::string", owner: "engine-core", phase: "unclassified", state: "unreviewed", line: 501}

‎ci/cr150-source-sites.json‎

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14470,7 +14470,21 @@
1447014470
"namespace pineforge #1",
1447114471
"inline namespace engine_script_run_v19 #1",
1447214472
"struct TradeLedger :: State #1",
14473-
"void ensure_cache ( size_type population ) const #1"
14473+
"void ensure_cache ( ) const #1"
14474+
],
14475+
"cls": "alloc",
14476+
"spelling": "make_unique",
14477+
"ordinal": 1
14478+
},
14479+
{
14480+
"file": "src/engine_orders.cpp",
14481+
"symbol": "page",
14482+
"scope": [
14483+
"namespace pineforge #1",
14484+
"inline namespace engine_script_run_v19 #1",
14485+
"struct TradeLedger :: State #1",
14486+
"CacheEntry & ensure_cache_entry ( size_type global ) const #1",
14487+
"if ( ! page ) #1"
1447414488
],
1447514489
"cls": "alloc",
1447614490
"spelling": "make_unique",

‎docs/adr/0001-kernel-adapter-boundary.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -86,7 +86,7 @@ summary of it.
8686
`NativeCoordinate::interval_index` (`market_driver.hpp:74`) is the sequential
8787
SCRIPT-bar index even when `input_tf` is finer than `script_tf`. The same
8888
script coordinate books `PyramidEntry::entry_bar_index`, trade-row indices and
89-
the inclusive bar metrics (`entry_bar_index` / `exit_bar_index` `engine_orders.cpp:127-128`, `bars` `engine_metrics.cpp:809`).
89+
the inclusive bar metrics (`entry_bar_index` / `exit_bar_index` `engine_orders.cpp:134-135`, `bars` `engine_metrics.cpp:809`).
9090
`NativeCoordinate::input_interval_index` (`market_driver.hpp:79`) names the
9191
input slot that supplied the point for a host that needs input cadence. Both
9292
coordinate values are folded by `hash_coordinate`

‎docs/design/native-feature-parity.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -885,7 +885,7 @@ between the halves. The mark itself is the same bar on both.
885885
(`fold_exit_trail_peak_` engine_run.cpp:109) and **never assigned a finite value anywhere in the
886886
tree**, so the `fold_exit_trail_peak_` checks
887887
(engine_execution.cpp:1120, :1135; `fold_exit_trail_peak_` engine_report.cpp:2288)
888-
and the shared producer's `preceding_exit_trail_peak` check (engine_orders.cpp:186)
888+
and the shared producer's `preceding_exit_trail_peak` check (engine_orders.cpp:193)
889889
are inert. The shared producer keeps the carry so it folds exactly what the kernel's settling path folds; removing the member is an epoch question (it is
890890
hashed as `fold_exit_trail_peak_` at engine_state_hash.cpp:86) and is left to a lane that budgets one.
891891
@@ -1720,7 +1720,7 @@ virtual void hash_host_extension(BrokerStateHashSink&) const {} // F (S: hash_
17201720
NativeMetricsView native_metrics() const; // S: net_profit, equity, closed_trades, open_lots; non-virtual
17211721
```
17221722

1723-
- `KernelRecorded`: the consumer calls the existing `update_equity_extremes()` (engine.hpp:1654) + `record_equity_point(script_open_ms)` (engine.hpp:1681) once per script calculation (after `invoke_callback` native_execution_consumer.cpp:8618, :8618, :8618, :8618) and after the `AfterCalculation` close; appends the per-bar broker hash when recording is on; synthesizes the open-position row at run end / `stream_end` with the existing `build_close_trade_with_costs` (engine_orders.cpp:75).
1723+
- `KernelRecorded`: the consumer calls the existing `update_equity_extremes()` (engine.hpp:1654) + `record_equity_point(script_open_ms)` (engine.hpp:1681) once per script calculation (after `invoke_callback` native_execution_consumer.cpp:8618, :8618, :8618, :8618) and after the `AfterCalculation` close; appends the per-bar broker hash when recording is on; synthesizes the open-position row at run end / `stream_end` with the existing `build_close_trade_with_costs` (engine_orders.cpp:82).
17241724
- `KernelRecordedAtHostMarks` (R1, KERNEL-EDGE): the same recording, at the points a C++ host names with `NativeStrategyHost::mark_native_report_point` instead of once per calculation; the consumer never records on its own initiative under it, so the continuation identity stays where `HostRecorded` leaves it. The Pine adapter's existing `mark_script_report_point` route has the same kernel producer. It is what the adapter declares (`KernelRecordedAtHostMarks` pine_adapter.cpp:3042), with `report_open_position_at_end == false`.
17251725
- Publish read-only `closed_trade_*` accessors (RP6).
17261726
- Alternative: F's virtual `owns_equity_recording()` (the A48 ownership pattern of `owns_lot_excursions` native_host.hpp:1043). Same semantics, but it costs a host-epoch bump, so the spec form was chosen; the virtual was never added, and `NativeReportPolicy` is what landed (§3.4 row 3).

‎docs/pages/memory-management.md‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -318,7 +318,7 @@ store; the part that spills grows in the scratch backing.
318318
| Store | Resident bound | Bytes per entry | Spills to scratch |
319319
| --- | --- | --- | --- |
320320
| Trade ledger (`TradeLedger`), descriptor window | 64 rows (`kResidentRows`, `include/pineforge/trade_ledger.hpp:41`), and a fixed payload tail of the same size | 168 B per row descriptor (`kRecordBytes`), so 10,752 B for the rows and 10,752 B for the tail; the four strings of a row are variable | Retiring sink runs erase published rows and return complete head chunks, keeping at most one zero-filled head chunk per extent plus the unsealed suffix; other runs retain 168 B plus text per closed trade |
321-
| Trade ledger, read cache | Up to 65,536 entries with or without a report sink (`kSinkCacheRows = kDefaultCacheRows`; the ceiling `kMaxCacheRows` is 1,048,576). Direct-mapped, allocated at the first read at the smaller of the cap and the next power of two that is at least the larger of 64 and the trade count (the comment on `TradeLedger::cache_resident_bytes`, `include/pineforge/trade_ledger.hpp:105-109`), so a run with few trades holds few entries. Chosen by the engine when the run begins, through `TradeLedger::set_cache_rows` (`src/native_execution_consumer.cpp:3192-3193`); the C API has no setter for it in this release | 312 B per entry (`kLedgerEntryBytes`: 168 B record, 16 B key and generation, 128 inline string bytes). The declared bound is `resident_cache_bytes(kSinkCacheRows)`: 65,536 x 312 = 20,447,232 B (19.5 MiB) plus `sizeof(TradeLedger)+sizeof(State)`, with or without a sink; the cap is independent of the trade and bar counts | Not applicable (a cache over the retained rows) |
321+
| Trade ledger, read cache | Up to 65,536 occupied entries with or without a report sink (`kSinkCacheRows = kDefaultCacheRows`; the ceiling `kMaxCacheRows` is 1,048,576). Direct-mapped by global index modulo the fixed cap; the first read creates a table of `ceil(cap/256)` owning pointers, and each first-touched page `p` allocates `min(256,cap-256*p)` slots (the comment on `TradeLedger::cache_resident_bytes`, `include/pineforge/trade_ledger.hpp:105-109`). Page growth preserves existing entries; writes fill only an existing cache. Retirement frees pages outside the retained window, bounding allocated slots by `min(cap,(ceil(retained_rows/256)+2)*256)`. Chosen by the engine when the run begins, through `TradeLedger::set_cache_rows` (`src/native_execution_consumer.cpp:3192-3193`); the C API has no setter for it in this release | 312 B per slot (`kLedgerEntryBytes`: 168 B record, 16 B key and generation, 128 inline string bytes); up to 79,872 B per page, with the last page clipped to the cap. The charge `resident_cache_bytes(cap)` is `sizeof(TradeLedger)+sizeof(State)+cap*312+ceil(cap/256)*sizeof(void*)`: at the default cap, 20,447,232 entry bytes (19.5 MiB) plus 2,048 table bytes on 64-bit targets and the fixed base. Actual allocation never exceeds this charge. Both caps are independent of trade and bar counts | Not applicable (a cache over the retained rows) |
322322
| Command journal | 2,048 events (`kMaxResident`, `src/native_order.cpp:1717`), in 32-event chunks (`kChunk`), with a floor of 128 events kept (`kKeepResident`) | Not a constant: an event is a variant with variable payload and `sizeof` of a resident slot is not stated in the source and was not compiled. Plus one lazy 163,840 B spill buffer per journal: a 32,768 B write buffer and four 32,768 B reload buffers (`SpillStorage`) | Older events, in pages of 32,768 B (`kSpillPageBytes`, `:1738`) read back through four decoded page slots. An event whose serialized form exceeds one page is refused with `EFBIG` (about 1,360 external openings) and stays resident |
323323
| Order book | 4,096 rows | See the drain plateau below | Older rows |
324324
| Command-store resident prefix / read cache | Fixed K = 202,752 B (198 KiB) per run: three 64 KiB page buffers plus 2 KiB per decorator, including slot keys (`CachedScratchBacking::kCommandScratchMemoryBytes`, `src/command_scratch_cache.hpp:28`; `static_assert(sizeof(CachedScratchBacking)` at `src/command_scratch_cache.hpp:76`); pages larger than 64 KiB or smaller than 512 B bypass the buffer | Counted in bytes; independent of extent and bars; replaces the previous read-cache allowance | Each disk store holds its prefix in the same buffer until its extent exceeds 64 KiB, then spills the prefix once and reuses the buffer as a read cache. Attached arenas retain direct mapped admission |
@@ -421,7 +421,7 @@ can add them up; each is read from the source named in
421421

422422
| Kind of store | Default budget | Resident memory at that budget |
423423
| --- | --- | --- |
424-
| Trade ledger | Descriptor window of 64 rows; read cache of up to 65,536 entries with or without a report sink. Chosen by the engine, not settable from the C API; cache allocation grows lazily up to the declared constant cap | 21,504 B for the window and its tail, plus up to 20,447,232 B of cache entries; `resident_cache_bytes(kSinkCacheRows)` accounts for the entries plus `sizeof(TradeLedger)+sizeof(State)` (including the window and its tail) |
424+
| Trade ledger | Descriptor window of 64 rows; read cache of up to 65,536 occupied entries with or without a report sink. Chosen by the engine, not settable from the C API; fixed slot mapping with pages of at most 256 slots, clipped to the cap, allocated on first touch and freed outside a retiring ledger's retained window | 21,504 B for the window and its tail, plus up to 20,447,232 B of cache entries and a lazy 2,048 B pointer table on 64-bit targets; `resident_cache_bytes(kSinkCacheRows)` charges both entries and table plus `sizeof(TradeLedger)+sizeof(State)` (including the window and its tail); actual allocation never exceeds that charge |
425425
| Command journal | 2,048 resident events, 128 kept at least | Not a constant per event; plus 163,840 B of spill buffers per journal once it first spills |
426426
| Placement rows | No budget: the live rows plus the rows the retirement rules pin | Not measured |
427427
| Id tables | Cohort table: resident rows follow the spill rule above (at most twice the rows left by the last pass, plus 64, plus pinned rows), and the bounded profile admits at most 4,096 live cohorts. The ordered index is read through a 64 KiB window per scratch file | 64 KiB per file; the index itself is on disk |
@@ -452,8 +452,8 @@ or bounds the row.
452452
| What | Grows with | Where it lives | Fix |
453453
| --- | --- | --- | --- |
454454
| C/C++ or Python host with no sink, including jailed Python without `--report-sink-fd` (the default route of the C API): equity curve | `N`: 24 B per script bar plus vector spare capacity, then another 24 B per bar for the owning FULL report copy when the default FULL report is built, plus the whole report text held until written (`O(output)`, about one byte of resident text per stdout byte on the jailed route; see [Report memory](#memory_sink)); sources in [Report memory](#memory_sink) | Heap | Install a report sink (no bounded default route exists in this release); account for disk scratch or jailed arena memory as above |
455-
| Same route (no sink): closed trades | `T`: 168 B plus text per trade | Scratch, with 64 descriptor rows resident and a read cache of up to 65,536 entries (312 B each, allocated as trades accumulate); the FULL report built from them is `O(T)` heap | Install a report sink |
456-
| Default report sink route (native or Pine host, history streamed or not) | Equity-report buffers are bounded (an editable tail and one 64 KiB writer batch, plus bounded metric-read windows); the ledger has 64 descriptor rows and a read cache capped at 65,536 entries, allocated lazily (20,447,232 entry bytes plus the fixed ledger/State base). Closed-trade rows below the published base are released only with an explicit no-history capability and a streamable policy (a read below the base then refuses with `engine_invariant`); otherwise the full history is kept (`O(T)`). The trailing block of rows that share the last exit time stays resident only when history is streamed (`K` lots closed at one time, `O(K)`). Binary curve scratch grows at 24 B per script bar; `E` output and the default path route's JSON artifact also grow | Disk scratch without an arena; RAM-backed scratch in the jailed arena, plus resident buffers and the sink file or stream; sources in [Report memory](#memory_sink) | Not applicable |
455+
| Same route (no sink): closed trades | `T`: 168 B plus text per trade | Scratch, with 64 descriptor rows resident and a read cache of up to 65,536 entries (312 B each, in 256-slot pages allocated on first touch plus a lazy 2,048 B pointer table on 64-bit targets); the FULL report built from them is `O(T)` heap | Install a report sink |
456+
| Default report sink route (native or Pine host, history streamed or not) | Equity-report buffers are bounded (an editable tail and one 64 KiB writer batch, plus bounded metric-read windows); the ledger has 64 descriptor rows and a read cache capped at 65,536 entries, in pages allocated on first touch (20,447,232 entry bytes plus the fixed ledger/State base and a lazy 2,048 B pointer table on 64-bit targets). Closed-trade rows below the published base are released only with an explicit no-history capability and a streamable policy (a read below the base then refuses with `engine_invariant`); retirement also frees cache pages outside the retained window; otherwise the full history is kept (`O(T)`). The trailing block of rows that share the last exit time stays resident only when history is streamed (`K` lots closed at one time, `O(K)`). Binary curve scratch grows at 24 B per script bar; `E` output and the default path route's JSON artifact also grow | Disk scratch without an arena; RAM-backed scratch in the jailed arena, plus resident buffers and the sink file or stream; sources in [Report memory](#memory_sink) | Not applicable |
457457
| Pine product host (`PineStrategyHost`) | It cannot select `STREAMED` or `SUMMARY_ONLY`. With a sink installed and the default report mode (the legacy route) its resident equity buffers and ledger cache are bounded as in the row above: the curve through the scratch writer (`ScratchCurveWriter` at `src/engine_report.cpp:1552`), selected by the Pine host's report policy (`KernelRecordedAtHostMarks` at `src/source/pine_adapter.cpp:3042`) and the install condition (`report_policy` at `src/engine_report.cpp:1546`); and the ledger at 64 descriptor rows (`kResidentRows` at `include/pineforge/trade_ledger.hpp:41`) with the sink read cache capped at 65,536 entries, allocated lazily. Adapter state (placement rows, settled bracket families, script containers) is separate and has its own rows below | Resident equity buffers and ledger cache bounded; curve scratch grows on disk or in the jailed RAM-backed arena; adapter state as the rows below | Not applicable |
458458
| A touched dormant leg that is re-issued | One placement row per re-issue, until the position cycle ends or the origin closes; an untouched re-issue with the same exit id replaces its row in place | Heap | Planned, with no release date |
459459
| Settled bracket families | One fixed record per archived family, which grows with `T` on a bracket strategy; not measured | Heap | Not scheduled |

‎include/pineforge/engine.hpp‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -2876,23 +2876,23 @@ class BacktestEngine {
28762876
return scratch_table_run_.slab;
28772877
}
28782878

2879-
// In-place closed-trade text comparisons (see TradeLedger::*_equals): an
2879+
// In-place closed-trade text comparisons (see TradeLedger::*_matches): an
28802880
// invalid index compares as the empty string, as the owning getters return.
28812881
bool closed_trade_entry_id_equals(int idx, std::string_view rhs) const {
2882-
if (idx < 0 || idx >= static_cast<int>(trades_.size())) return rhs.empty();
2883-
return trades_.entry_id_equals(static_cast<std::size_t>(idx), rhs);
2882+
return trades_.entry_id_matches(idx, rhs);
2883+
28842884
}
28852885
bool closed_trade_exit_id_equals(int idx, std::string_view rhs) const {
2886-
if (idx < 0 || idx >= static_cast<int>(trades_.size())) return rhs.empty();
2887-
return trades_.exit_id_equals(static_cast<std::size_t>(idx), rhs);
2886+
return trades_.exit_id_matches(idx, rhs);
2887+
28882888
}
28892889
bool closed_trade_entry_comment_equals(int idx, std::string_view rhs) const {
2890-
if (idx < 0 || idx >= static_cast<int>(trades_.size())) return rhs.empty();
2891-
return trades_.entry_comment_equals(static_cast<std::size_t>(idx), rhs);
2890+
return trades_.entry_comment_matches(idx, rhs);
2891+
28922892
}
28932893
bool closed_trade_exit_comment_equals(int idx, std::string_view rhs) const {
2894-
if (idx < 0 || idx >= static_cast<int>(trades_.size())) return rhs.empty();
2895-
return trades_.exit_comment_equals(static_cast<std::size_t>(idx), rhs);
2894+
return trades_.exit_comment_matches(idx, rhs);
2895+
28962896
}
28972897

28982898
// The last point stays editable until its successor is recorded. Sinks

0 commit comments

Comments
 (0)