Skip to content

v0.5 joint export: tables, window, frame word, plan every strategy, warm-keep - #153

Merged
afflom merged 65 commits into
mainfrom
claude/project-thread-3xjoco
Nov 12, 2026
Merged

afflom merged 65 commits into
mainfrom
claude/project-thread-3xjoco

Conversation

@afflom

@afflom afflom commented Nov 12, 2026

Copy link
Copy Markdown
Member

Requested by Alex · project thread

One export of the v0.5 lanes, with the generated client crates rebuilt from it. It carries #147 (table bits facet) and #148 (window depth and match table facets) and merges main at 870a46e (#141).

What it contains

  • Table bits and window facets (Context table bits as a per-frame facet (carried by #153) #147, Window depth and match table bits as per-frame facets (carried by #153) #148). The context table, window depth and match table bits are stepped on the chosen archive while it gets smaller and the declared decode host still holds it.
  • The 64-bit frame word. The low 32 bits are the profile. Bits 32-36 are reserved. The streams count minus one sits at bit 37 and the log2 of the epoch at bit 53. In v0.5 the streams and epoch fields are reserved and must be zero (see below).
  • Lane 4's patches.
    • Every strategy the frame can code is planned, by weight, with no budget.
    • Client.search is exported as its own root.
    • Twin strategies share one pass, and state twins replay the state once.
    • Every warmed model state the declared host has room for is kept (warm-keep).
    • The plan's facets are in Uorc.Performance.
  • The UC-PERF-08 sentence. It now says the client's choice is the rule, in the model (Client.pick) and natively.
  • The exported client. generated/rust/uorc_compress, uorc_decompress and uorc_search (3 packages from 77 modules). The export identity matches after the merge with main.

Fixes found while exporting and testing

  • Increment trap. Client.matchLoop passed (mb + 1) into prim multiply 67108864 …. The Lean kernel turned that into _ + 67108864 and unfolded the addition about 67 million times in preservation certificate R1, which went past 13 GB. The increments are now literal-first, (1 + mb) and (1 + tb), in matchLoop and stepLoop.
  • Warm-model decode length. A warmed model kept for reuse was sized for the first frame it coded, so a later, shorter frame decoded to the earlier frame's length. Decode now returns exactly the frame's bytes. UC-PERF-05 caught it.
  • Frontier register. A fixed codec point that continues a model state now records that state (from_state), so its κ recomputes from the record. The engine's tick failed on this on main.
  • Tests.
    • UC-PERF-16 repeats a frame that no warm state predicts. A state frame now wins its README input, and the window step does not apply to state frames.
    • The page's per-strategy wasm test steps the chosen archive (step_frame) the way the page does.

What it does not include

  • The streams coder in the shipped client.
    • The streams coder (ncm::streams) and its IR model (client/gen/ncm_streams.py) stay in the repo as tested, unshipped work. They are byte-equal at 2, 3 and 4 streams, with merge steps counted the same way. The client's compress and decode paths do not reach them.
    • The frame word's streams and epoch fields are reserved and zero. The native, WebAssembly and exported decoders all refuse a frame where they are not (archive::frame_word, Archive.profileWord), so no archive decodes in only one client.
    • --host-threads, step_streams and Client.stepStreams are removed.
    • Distance, recorded in Uorc.Performance (streamsPerFrame, unmet):
      • The codec modules grow from 0.14 MB to 0.61-0.69 MB with the streams tables grouped, and to 1.0-1.1 MB ungrouped.
      • Extraction exceeds Lean's heartbeat budget.
      • With that budget lifted, extraction runs over 80 minutes before lexlean is killed at 12.5 GB of a 15 GB limit.
  • The 16-bit probability field. It is not in this export.
  • Other unmet items, stated with their distances in Uorc.Performance:
    • The stream epoch is derived only by trials (streamEpoch).
    • A frame decodes on one thread whatever the host has (archiveWidth).
    • Block restart is not yet derived (blockFrames).
    • The full plan's compress time and state replay are still to be met (planCompressTime, stateReplayTime).
  • No workspace version bump.

Checks run locally

  • uorc tests (cargo test --release -p uorc): all pass. That is lib 82 (including native == exported model), cli 8, conformance 10, neuromorphic 3, performance 10 and shipped_states 2.
  • Other crates: frontier (6), uorc-engine, uorc-wasm (4), repo-conformance and repo-model pass.
  • xtask: 25 of 26 pass. product_execution::generated_search_and_core_controls_execute needs the project SDK's lexlean, which is not available in this container, so it was not run here.
  • Clippy and fmt: cargo clippy -D warnings is clean on uorc, frontier, uorc-engine, uorc-wasm and xtask. cargo fmt --check is clean.
  • Model projections: xtask check-model --write after merging main changes nothing.
  • Register: cargo run --release -p frontier -- check gives ok: 3 corpora, 1 points, 4 claims. cargo run --release -p uorc-engine -- status passes and loads the register.

Generated by Claude Code

A step is one model input evaluated for one coded bit, read from a frame
header alone. A codec point names basis, profile word, state and lanes.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LszhHCxmceQ2V8xxx
Uorc.Performance (src/Uorc/Performance.lex.tex) states the client's size,
choice, decode cost and meaning as theorems that hold for every input, each
kernel-checked:

- archiveBound: a frame is settled against its raw frame, and the raw frame
  is 2 length varints (at most 10 bytes each), the input and 41 fixed bytes,
  so no one-object frame exceeds n + 61 bytes.
- bestNoLargerThanEvery: the trial the portfolio keeps is no larger than any
  coded trial it scheduled.
- decodeStepsBound: a step is one model input evaluated for one coded bit;
  a profile evaluates between 3 and 24 inputs, so decode takes at most 192
  steps per modelled byte for every frame kind (raw, reference, ncm, ncm
  from a named state). Closed vectors: FULL 192, V03 160 steps per byte.
- bestOfAdmittedIsExact: admission fails every trial whose decode differs
  from the input, so whichever codec point or named state coded a frame,
  only its size can change.
- dominance (no larger in bytes and in steps) is irreflexive, transitive,
  never grows either coordinate, and its gain is bounded by the cost drop,
  so consolidating winners cannot cycle.

The theorems are about the model's rules. tests/performance.rs holds the
native constants equal to the model's, the theorem inventory complete, and
every sampled native frame within the bounds (raw length, n + 61, no larger
than each scheduled strategy, decodes to its input, steps within 192 n).

The codec point's profile word carries bit 31 for the x86 filter
(performance::POINT_X86), the strategy table's encoding.

Registered as UC-PERF-02..06 (kernel_theorem), suite performance-theorems.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LszhHCxmceQ2V8xxx
Registry keeps UC-WEB-01 and UC-PERF-02..06; projections regenerated (34 ids).

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LszhHCxmceQ2V8xxx
…l (UC-PERF-07..09)

Nineteen more kernel-checked theorems, drawn from what the rule30 work
established (a finite horizon decides a candidate; a known result is not
redone; a potential that only falls):

- boundedPortfolioSettlesTheSame: a trial abandoned at the raw length is a
  trial of at most that many bytes, and the portfolio of abandoned trials
  settles to the same size as the portfolio of complete ones. A trial no
  smaller than a kept one changes neither the kept bytes nor steps.
- chosenIsLeast, chosenIsNoWorseThanRaw, chosenKeepsTheSize,
  leastIsUndominated: choosing by fewer bytes, then fewer steps, keeps a
  trial no later than every listed trial and the raw frame, of exactly the
  size the bytes-only rule settles to, dominated by none of them.
- consolidationSpendsItsGain, potentialNeverRises: consolidating a
  candidate lowers bytes plus steps by exactly its gain, and over any
  sequence the potential never rises.

Native: performance::{Trial, gain, lex_gap, pick, chosen, consolidate},
tested exhaustively over small keys against the theorems' statements; the
encoder's bound returns the complete payload or none.

The released client still breaks byte ties by schedule order; UC-PERF-08
says so. The bytes-then-steps rule enters with the next model export.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LszhHCxmceQ2V8xxx
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LszhHCxmceQ2V8xxx
A state frame continues a kappa-named ncm model state: the whole model
codes the state's bytes first (no coder output) and the frame is coded
as its continuation (library block ncmRunWarm, entries ncmw/ncmwx).
State 1 is 256 KiB of this repository's own text at tree 99c4290.

The portfolio reads its strategies, weights and states as model data,
codes each family's schedule (4 tiny/small, 3 text, 2 x86/other) with
every state-free strategy learning its mask, so each family's schedule
holds the strategies v0.4 coded. v0.4 becomes a decode era; each era's
library is named as a prefix of the current one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
…to claude/project-thread-jp5j6j

# Conflicts:
#	client/src/Uorc/Client.lex.tex
#	crates/uorc/examples/portfolio_outcomes.rs
#	crates/uorc/src/portfolio-outcomes.tsv
#	crates/uorc/src/portfolio.rs
The portfolio keeps the trial with fewer bytes, then fewer decode steps
(Client.pick, the right fold Uorc.Performance.chosen states), and never
codes an x86 trial whose filter rewrites nothing. Native mirrors both
(portfolio_trials, pick_trial) with tests for UC-PERF-07 and UC-PERF-08.

The state identity is written with a window count the kernel cannot
reduce, so the export's certificate no longer evaluates the closed
library prefix (it ran out of memory there).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
The sequential portfolio stopped a learning pass at one byte past the least
archive so far, which also dropped the learned profile that could have been
shorter: the page's side-by-side workers found a 1-byte smaller second frame
than the library (pages acceptance differingArchives). The learning pass is now
bounded by the raw archive only, so the kept archive is the model's fold in
either mode. The state warm-up now calls the progress hook every 16 KiB like
any other pass (page progressGap).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
…hort states

State-free profiled frames are written over the v0.4 basis with its frozen
tails (Archive.profileCandidate, native linked_archive_profile), so such a
frame is exactly the frame v0.4 writes: the appended warm blocks had pushed
the x86 block's distance in the current tails past one uleb byte (+2 B).
Exported model regenerated.

State 2 is the last 64 KiB of state 1, with strategies FULL and MID from
state 2; weights learned from the regenerated training outcomes. The unit
tests run the client over the last 2 KiB of each state (the exported model
replays a state at ~40 us per bit: 180-207 s for a tiny frame under state 1);
tests/shipped_states.rs checks the shipped states against the model.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
Main's engine-generated portfolio table now carries the two states: model/engine.toml
holds the ten strategies (v0.4's six, FULL and MID from state 1, FULL and MID from
state 2) and their weights, and crates/uorc/src/weights.rs is rendered from it.
Table::strategy accepts an entry whose state the basis has.

Client.planned (native Table::plan): the encoder codes the first budgetFor(f)
scheduled entries and then each strategy of the family's v0.4 pair the schedule
did not reach, so the kept archive is the least of a superset of v0.4's trials:
no frame is larger than v0.4 coded it, whatever the weights.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
…(encoder, probes)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
…frame while it pays and the decode host holds it

The profile word records the context table's bits (bits 20-25) and the
match tables' bits (bits 26-30) when a frame steps them; 0 keeps the size
the frame's length gives, so a frame where no step pays is byte-identical
to before. The v0.4 era refuses the fields. The client steps the context
table one bit at a time on the portfolio's chosen archive while the archive
gets strictly shorter and the declared decode host holds the decoder
(ncm::decoder_bytes; default the page worker, 256 MiB; --host-memory
declares another). The IR reads the fields (checked equal to the native
coder), the graph's context table moves above every other table, and the
model's Client.stepTable is the same rule; the page steps the kept archive
for its worker (step_frame).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3NK2ctbZVyMzHXqU8M
…allel merge), probes

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
…n-place history

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
… export 11

CodecPoint::of reads the kappa of the state a frame continues from its header.
The conformance basis check accepts the v0.4 or a state basis for a large text,
and that continuing a shipped state makes small text smaller is checked on the
shipped states (tests/shipped_states.rs) rather than on the short test slices.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
…are tables and output copy

performance::Host gains keeps_tables and footprint(); PAGE_WORKER is one
page worker (512 MiB, the budget uorc.js gives a pool worker); a host
declared with --host-memory is a native decoder. The model's
Client.hostMemory and pageBytes state the same.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3NK2ctbZVyMzHXqU8M
…ent one

ncm_v04.py freezes the coder v0.4's profiled blocks compile from, so the
v0.4 library stays byte for byte; the current coder (ncm_model, which reads
the profile word's table fields) is appended as ncmRunTables after the v0.4
blocks, and the current era's profiled entries apply it. The library grows
from 40 KB to 51 KB. The export regenerates the templates and modules.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3NK2ctbZVyMzHXqU8M
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3NK2ctbZVyMzHXqU8M
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
…ntry for any depth

The profiled window entry is one form for every depth k (three graph nodes
per frame); k = 1 and 2 are the fixed entries byte for byte and the decoder
reads k from the entry. After the portfolio (over the last two frames), the
chosen coding steps its window one earlier frame of its block at a time,
then its match table bits one at a time, each kept only while the archive
gets strictly shorter and the decoder fits the declared host. Decoders keep
every earlier frame of a block (REACH). The model's Client.stepWindow is the
same rule; the page steps the kept archive the same way. Rows UC-PERF-16/17.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3MkN6HPQ5xygtzPi5c
…ve encode and decode of stream frames, merge step counter

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
…tate

The merge keeps #143's portfolio (every planned strategy without a state
learns; the model's right fold of pick) and main's shared-pass encoder
(ncm::encode_pair_below) beside the warmed encoder.

search_keeps_only_checked_candidates codes 5,000 zero bytes, a small frame
whose plan continues no state: with steps > 0 the whole compress runs on the
exported model, which replays a shipped state at about 40 µs a bit (the test
took 410 s on 200 bytes, a tiny frame that continues S1).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
When no core is spare, each state-free strategy of the plan codes with the
first later strategy that differs only in mixer selection in one pass
(ncm::encode_pairs_learn_below): the twin learns its mask from its own mixer 1
over the shared mixers 2 and 3, so both payloads and both learned profiles are
the ones their own learning passes find (UC-PERF-11 test, both directions,
with and without a window). Archives are unchanged; one thread compresses
lcet10 4.56 s (was 5.79), py_topics 6.06 s (6.83), kennedy.xls 5.06 s (5.56).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
…e-identical to the native coder; a match points only into the past

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
Host keeps workers (frames decoded at once) and threads (one frame
decoder's threads) apart; the streams step follows the table step; a
model's history still grows when it codes past its sized length.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
The portfolio codes every scheduled entry of the frame's family, in weight
order, then any v0.4 pair strategy the table lacks. Client.budgetFor and
takeNat are gone; portfolio::budget and BUDGET are gone; MAX_PLAN is the
shipped table's entries plus the pair. Needs the joint export.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
… only the search on the model

compress with steps > 0 is the smaller of the portfolio archive (native, the
model's bytes) and the exported search's (uorc_search, Client.search): the
model's warm states are no longer replayed by the exported coder for a search
(about 40 µs a bit). Needs the export to write generated/rust/uorc_search.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
…patch, Client.stepStreams

The IR streams model sizes every region by the frame (one entry space of
the merged tables, per-stream values at j * zs), counts the merge's steps
as native does, and lowers to NcmDecode/NcmEncode (runStreams,
countStreams). Archive reads a frame word (frameWord) and dispatches one
stream to the frame's coder, more to the streams coder. Client.stepStreams
derives streams and epoch after the table step on the declared decode
host (hostThreads 1 on the page worker: the step is the identity there).
A stream's coder abandons the encoding past twice its length and 64
bytes, as the frame's coder does, in native and model.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
…width unmet, match-from-past rule

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
The tree already holds #143 at e0ef1af; main adds only ea75e13's
web/uorc.js change, applied in the next commit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
streams_are_frames_end_to_end no longer recodes its 16 MiB in memory (the
stream-equals-memory check across thread counts is identical_frames'), nor
decodes it a second time; objects_stream_across_frames checks the one-object
header on a small object; windows_carry takes the lone-frame size from the
stream's first frame and decodes once; the two wasm frame-export tests share
one input and its library stream, and the whole-frame export is checked on
the tail frame. Measured debug profile: lib frame tests 624 -> 387 s, wasm
277 -> 185 s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
…nmet

A structural recursion may not reuse its scrutinee in an arm (windowFrames,
recentWindow, lastFrames); frameWord without a let named k, axioms []. The
UC-PERF-08 row says the client's choice is the rule in the model and natively.
Uorc.Performance records the full plan's compress and small-file decode time
as unmet for hostCeiling.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
The number of warmed models a process keeps was a constant (2 natively,
none on the page). It is now the host's rule, Host::warmed_kept and
Uorc.Page::warmedKept: the host's memory less the frame's decoders, over
one warmed model's bytes (its tables and the state). On the page worker
(512 MiB) a small frame after S1 keeps 3 at the default tables, 1 at
2^25 slots and none at 2^26. A kept model changes decode time only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
scheduleBudget now states that every strategy the frame can code is
tried; planCompressTime and stateReplayTime record, under hostCeiling,
the measured distances: compress of the full plan against the budgeted
one, and the state replay a process pays before its first state frame,
with the image a host with persistent storage would keep.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
… state it)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
Twins (profiles differing only in ncm::F_SEL, same transform and state)
now code in one pass whether the strategies run one after another or side
by side; before, they shared only on one core. State twins (FULL+S1 and
MID+S1) replay the state once and code the frame in one pass
(ncm::encode_pair_warm_below), and learned twins whose pruned profiles are
themselves twins recode in one pass (Prepared::settle_pair). Every payload
is the one its own pass writes (UC-PERF-11 now covers the warm pair), so
the archives are unchanged: 39 files byte-identical, compress 105.4 s to
67.5 s on 4 cores.

The UC-BAS-01 test codes its large text by the full-model strategy: under
the full plan the portfolio may keep the v0.3-era entry for it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3Pwxeo6151E56VetgS
The streams coder's lowering does not fit the export: the codec modules
grow from 0.14 MB to 0.61-0.69 MB (tables grouped by shape, constant
offsets) and extraction runs over 80 minutes before lexlean is killed at
12.5 of 15 GB. In v0.5 a frame is one stream: the frame word's streams
and epoch fields are reserved and zero, and the native, wasm and exported
decoders refuse a frame where they are not (archive::frame_word,
Archive.profileWord). --host-threads, step_streams and Client.stepStreams
are removed; ncm::streams and ncm_streams.py stay as tested, unshipped
work (Uorc.Performance streamsPerFrame, streamEpoch, archiveWidth unmet,
with the export distance).

Client.matchLoop and stepLoop pass their increments literal-first
((1 + mb), (1 + tb)): (mb + 1) under prim multiply 67108864 made the
kernel unfold 67 million additions in preservation certificate R1.

A warmed model kept for reuse was sized for the first frame it coded;
its decode now returns exactly the frame's bytes (UC-PERF-05 caught it).

frontier: a fixed point from a model state records the state, so its κ
recomputes from the record (the engine's tick failed on it).

Tests: UC-PERF-16 repeats a frame no warm state predicts; the page's
per-strategy test steps the chosen archive as the page does.

Generated crates re-exported: uorc_compress, uorc_decompress and
uorc_search (3 packages from 77 modules).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
afflom pushed a commit that referenced this pull request Nov 12, 2026
Compressing 10 MiB of text grew one WebAssembly worker to 603 MiB
(701 MiB across the pool) against its 512 MiB share. The table facet
tries a larger context table, and two things followed from it.

- The encoder kept a warmed copy of every table size it tried. An
  encoder's warmed model is one trial and nobody reuses it, so encoders
  now read the warmed cache and keep nothing in it.
- Decoders count the warmed models they keep by bytes, whatever table
  size each was warmed for, and evict before they allocate
  (Host::warmed_room).
- In wasm, a dropped table is kept as a spare. There are only as many
  spares as one model holds, the largest are kept, and a smaller table
  takes part of a larger spare. Before this change, freed tables of one
  size left holes that the next, larger size could not reuse.

Measured on one worker, the large page input compresses with 362 MiB
(was 603) and decodes with 301 MiB (unchanged). Archive bytes and
times are the same.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P1B7TPp4PBMQsB1QM
@afflom
afflom merged commit e787b7c into main Nov 12, 2026
16 checks passed
@afflom afflom mentioned this pull request Nov 12, 2026
afflom pushed a commit that referenced this pull request Nov 13, 2026
The x86 rest leg was cancelled at its 60 minute limit on this PR with its
tests still running; it took 52 minutes on #143 and passed on #153 within
the limit. v0.5's client tests sit at that edge, so the rest legs take the
guard the artifacts and integrity legs already have.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LszhHCxmceQ2V8xxx
afflom pushed a commit that referenced this pull request Nov 15, 2026
…structure)

The streams branch (1296db3) carried the test's v0.4 form, which repeats
README.md. On text the portfolio's warm-state frame wins (2,551 B against
2,692 B for the profiled frames over the noise window) and the window step does
not apply to state frames, so the deep archive names no window. Main replaced
the frame in #153 for this reason; the merge took the older form back.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3P3msaM1qmuGgGtMYE
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants