- check if self-moves are actually problematic, currently we guard against it.
- afters_of | befores_of, can they return sortedidvec? seems that way.
Where: src/encoding.rs block derivation and emit (CanonRun, Block, Payload, visit_refs, producer, resolve / encode_ref); encode_hashkv_with_store.
Done so far: InternedHashNode (src/interned_hash_node.rs) is the HashNode / Op shape with every ref a NodeIdx. Both projections resolve a node once at the apply seam (orphan_or_dispatch; the Err is the orphan key) and interpret takes the interned form; the stored forms are built from it by move (StoredRun.at, StoredMove.to, StoredMark.start/end are InternedAnchors); HashSeq::interned_at is the one stored-form → node seam and node_at is interned_at(..).to_node(&ids); the clock walk and the encoder's depth pass take edges from HashSeq::for_each_ref with no probes; HashKv::nodes is a Vec<InternedHashNode> parallel to order (origin at slot 0). The encoder no longer calls idx_of. Perf-gated: target/perf/item44-baseline-d203db5.txt vs item44-after.txt, encoded bytes unchanged.
Problem: the block layer still works in id space. CanonRun.first_pins / interior, Payload::*::extra_deps / targets and Block.exposed are rebuilt as BTreeSet<Id> / Vec<Id> from handles, producer is an FxHashMap<Id, _> over every exposed id, and encode_ref hashes a 32-byte id per ref to find its block. The kv encoder likewise sorts all_nodes() and ranks through an index_of: FxHashMap<Id, usize>.
Fix: keep block bodies as handles (SortedIdVec pins, NodeIdx targets), make producer a Vec<(u32, u32)> indexed by handle, and go to ids only for the dictionary and for orphans (whose refs may be unknown). Byte-identical output is the gate: the strict round-trip and determinism tests, plus the size tables of sequential_traces.
Where: src/hashseq.rs node_at, StoredRun::char_at.
Problem: char_at(pos) falls back to text.chars().nth(pos) whenever text.len() != elements.len(), and node_at calls it once per element. Delta emission and the clock walk's closure marking both go through node_at, so a drain or a hello over a non-ASCII run is quadratic. Release: 100k ASCII = 3.3 ms; "é" + 99,999 'a' = 376 ms. The wasm client drains every 200 ms and basecamp drains synchronously after every mutating call.
Fix: give StoredRun an O(1) char accessor for the mixed case, or reconstruct per run with one text.chars().zip(elements) pass as all_nodes does.
Where: src/hashweb.rs deltas_for, frontier.
Problem: each has a seq loop and a kv loop differing only in KIND_SEQ/KIND_KV. deltas_for also runs a walk per object per drain, cheap but unconditional.
Fix: share the loop body (hoist encode_hashweb_with's ObjRef { Map, Seq }). If per-drain cost shows, a per-object dirty flag skips objects untouched since the clock last advanced.
Where: src/hashseq.rs interned_at / for_each_ref (Run arm), src/encoding.rs elem_pins / elem_anchor, src/run.rs Run::decompress_with_ids.
Problem: "element 0 carries at + first_pins, element i > 0 is After(elements[i-1]) + interior_pins[i]" is written out in each. (The per-kind reconstructors are gone: node_at is interned_at(..).to_node(&ids), and all_nodes uses it for everything but char runs, which stay batched per run so item 3's cost does not leak into merge.)
Fix: one StoredRun::elem(pos) -> (InternedAnchor, Option<&SortedIdVec>) that the three share.
Where: src/hashseq.rs:276 (broken rustdoc link [`Run::interior_extra_deps`], cargo doc warns), src/run.rs:19,23,58, src/hashseq.rs:155,488.
Fix: replace first_op / FirstOp::Before / extra_deps with at / Anchor::Before / interior_pins / pins.
Where: src/hashseq.rs:52.
Problem: if *e.get() != idx { spill } cannot be false: the only caller intern always passes the arena tail, which no existing prefix entry can hold.
Fix: Occupied(_) => { self.spill.insert(id, idx); } with a note that each id is interned once.
Where: src/hashseq.rs ~:2609.
Problem: // TODO: why not the visible right neighbor? sits above the comment that answers it (Fugue rule; region_first guarantees no before-children).
Fix: delete it or fold the question into the existing comment.
Where: src/encoding.rs:296 and the BLK_RUN_* emit ~:1499.
Problem: run frames encode After=0x00, Before=0x01; Anchor::side_bit in the node preimage is Before=0, After=1. The op-stream form is live on the wire, so flipping is not viable.
Fix: one-line comment on the RUN_OP_* / BLK_RUN_* constants saying the polarity is deliberately opposite to side_bit.
Where: src/hashweb.rs, the src/hashseq.rs apply path, src/encoding.rs decode_payload.
Problem: the by-id payload form is never refused; the id is resolved on read when the replica knows the value. Small values are done (2026-09-24): artifacts of ≤ 15 bytes are their own value id (GRAMMAR_SPEC.md "Identity-form value ids"), so a char — or any small value — sent as 0x01 id resolves from the id on every replica with no artifact and no table; steps 1–4 below remain only for hashed (16–32 B) artifacts. Still open: the spec says inline 0x00 len bytes is mandatory for any artifact ≤ 32 B, but the encoder inlines only Payload::Char and the decoder drops the bytes of an inline non-char artifact.
Plan: keep the store on HashWeb; resolve at apply and re-resolve on artifact arrival; no signature change to iter/char_at; never use CHAR_MEMO (thread-local, history-dependent).
HashWeb::resolve_char(id) -> Option<char>(ASCII table, elsevalues→Value::decode→Char) andresolve_node(node)rewritingOp::Insert{Payload::Id(v)}on hit, id unchanged.- Route seq deliveries in
apply_to_with_idthroughresolve_node; orphaned nodes resolve on wake;mergealready passes through it. HashSeq::resolve_atoms(vid, c) -> usize: for eachelem_payloads[e] == vidset the single-element run's text toc, drop the entry. Run length unchanged so RunIndex is untouched. Strict round-trip test that a resolved 1-char run encodes identically to a typed one.- Call
resolve_atomson every seq when new bytes decode to a non-ASCIIValue::Char:provide_artifact_bytes,provide_value,merge,decode_hashweb. - Thread a value sink through
decode_*_into(bytes, &mut Vec<Vec<u8>>)sodecode_hashweb/ wasm ingestion capture inline non-char artifacts intoweb.values. - Tests: by-id non-ASCII char applied before and after its artifact arrives renders as the char; ids equal;
payload_of→ None after resolution; strict web round-trip of resolved state. - Docs: HASHSEQ_SPEC.md "Payload" (~:99) and the
ATOM_CHARdoc: placeholder means "until resolved".
Note: seq stream bytes change once an atom resolves (0x01 id → 0x00 len bytes, mandatory per GRAMMAR_SPEC "Stream references and value elision"), so decode_hashweb_strict of an old snapshot holding a by-id atom plus its artifact reports NotCanonical after resolution. Correct per spec; a visible behaviour change.
Where: src/run_index.rs:112 Frag::select / rank on Bits::Large.
Problem: linear word scan; RunIndex::get is called twice per cursor_at, so ~2.2k words scanned per keystroke at the tail of a 69k-element run. Constraint: Bits::Small(u64) stays exactly as is; nothing may cost the measured gains.
Fix: inside Bits::Large only, a visible count per superblock of 8 words (512 elements). select skips whole blocks then scans ≤ 8 words; rank sums blocks below k then ≤ 8 words. push_visible/set_bit/clear_bit adjust one block count; split_bits rebuilds. Gate: cargo run --release --example sequential_traces vs target/perf/review-after-e2.txt, no regression on clownschool / friendsforever / json-crdt or it does not land. Also debug_assert_eq!(frag.visible, popcount(bits)) at the six mutation sites.
Where: src/run_index.rs:201 IndexTarget, attach_at (~672-726), index_target (hashseq.rs ~996-1030).
Problem: six paired Before*/After* variants. Collapsing to (slot kind, before: bool) folds the four Moved/Splice arms of attach_at; the two Elem arms carry different split logic and stay.
Fix: only alongside the next change that touches attach_at, and measure.
Where: src/hashseq.rs ~:1006.
Problem: the admission whitelist (now one predicate, is_glue_point), the rendered-vs-splice-ghost predicate (index_target ~:1010, ensure_op_fragment ~:1421, op_point_pos ~:1509, hashseq_iter.rs:87), and the ensure_op_fragment pre-call at 5 sites.
Fix: one resolve_glue(anchor) -> Option<IndexTarget>.
Where: src/hashseq.rs ~:106 PackedLoc and the per-kind side tables.
Problem: 3-bit kind with 7 of 8 used, _ => Loc::MultiRemove catch-all, no debug_assert on kind range in pack. The next-but-one op kind silently corrupts the handle. Every kind still has its own side table, but the hand-written arms are down to three: interpret, interned_at (the reconstruction seam every walker shares) and for_each_ref (its allocation-free edge twin, kept equal by check_for_each_ref_matches_interned_refs).
Fix: a debug_assert on the kind range and a comment on the budget.
Where: src/hashseq.rs ~:1369 register_op_fragment vs insert_after (~1061-1110).
Problem: register_op_fragment mirrors insert_after; after_sibling_target vs before_sibling_target have different shapes.
Fix: one attach_sibling(anchor, side, id).
Where: src/encoding.rs ~:642.
Problem: Move / Mark / Place / atom inserts all go to the trailing section as individually tagged nodes re-applied via seq.apply (full rehash). A KB workload (moves, marks, embeds) loses run compression.
Fix: block forms for the op kinds the KB emits, or at least a batched re-apply that skips the rehash.
Where: src/encoding.rs:2109 WIRE_ARTIFACT_MAX = 1024, src/hashkv.rs:136.
Problem: a Put value > 1 KiB is stripped from the hello snapshot and never lazily fetched, so the register is missing forever on fresh peers. Overlaps item 34.
Fix: decide by role (register values always ride; large blobs are fetched by id), or add a lazy fetch path on Read::One(id) misses.
Where: HASHSEQ_SPEC.md:186-189.
Problem: the spec says "left causally-before right → Before(right), else After(left)" while cursor_at implements the Fugue rule.
Fix: rewrite the paragraph to describe the rule cursor_at implements, and say what "block non-interleaving" claim survives.
Where: src/hashseq.rs:114.
Problem: needs 512 MB of run text to overflow, then silently corrupts the handle in release.
Fix: split the run before the limit, or return an error from the insert path.
Where: src/encoding.rs:2260 test_id, :3470 oid, and siblings.
Fix: one shared test helper module.
Where: src/hashseq.rs apply_with_id (and HashKv::apply_with_id); src/hash_node.rs HashNode::id only debug_assert!s normalization.
Problem: a node with a redundant pin (pin = its anchor) hashes to the same id as its normalized twin and is accepted; so is a ref-less Remove({}). The replica then stores a form its own snapshot cannot decode (RedundantPin / NoRefs) — every peer rejects its snapshots and deltas; debug builds panic in apply. Reachable through the public API and merge from an untrusted HashSeq; every network path goes through validate_node. (2026-09-24 review.)
Fix: run the validate_node rules (is_normalized, non-empty refs) in apply_with_id and refuse, or normalize before interning.
Where: src/encoding.rs decode of BLK_REMOVE_FWD | BLK_REMOVE_BWD (~1651) and BLK_REMOVE_OTHER segments (~1712).
Problem: each ~8-byte remove-span block mints a whole chain over an existing run, so N blocks with distinct first pins mint N × run-length nodes (measured 4.9 KB → 250k nodes; ~1 MB of input is an OOM). REMOVE_OTHER segments need not be sorted or disjoint: S overlapping segments cost S × L. Strict mode does not help — it decodes before comparing. ENCODING_SPEC claims decode is never superlinear. (2026-09-24 review.)
Fix: require segments strictly ascending and non-adjacent, and enforce a global expansion budget (expanded targets + minted nodes ≤ c × input bytes).
Where: src/encoding.rs apply_delta (~3370): create_seq / create_kv per group before any node is checked.
Problem: ~34 bytes per junk object, even for empty groups and for deltas later rejected; the junk persists in every snapshot and ships to peers, while delivered reports 0. (2026-09-24 review.)
Fix: open an object only once one of its nodes applies (or orphans), and never on a rejected delta.
Where: src/encoding.rs decode_node_with / block tags (InvalidOpTag); GRAMMAR_SPEC.md "Grammar-level validation".
Problem: the spec says unknown kinds are not malformed and must be carried opaquely, but every decoder rejects them, and the standalone/trailing node form (tag ‖ pins ‖ per-kind fields) has no length envelope, so an unknown kind cannot even be skipped. One future-kind op aborts a whole delta or snapshot: adding a kind is a hard fork. Related: clocks ignore refusals, so replicas that disagree on a verdict (a "loosening" upgrade) re-ship the same suffix on every sync. (2026-09-24 review.)
Fix: decide the extension story — a length-framed node envelope on the wire plus carry-opaque storage — or amend the spec to "unknown kinds are a hard fork".
Where: src/hashseq.rs resolve_decider_with (~1108), called on every apply_move.
Problem: a "ladder" history (a_k, b_k each overwriting {a_{k-1}, b_{k-1}} — two synced users repeatedly moving the same element) re-resolves the whole ladder per apply, with an O(n²) ancestor memo: 1,600 ops take 14 s. Honest-reachable, and decode replays it. (2026-09-24 review.)
Fix: a generation number per move op and an iterative descent of the maximal common set, or cache the last-agreed op per antichain incrementally.
Where: src/run_index.rs rng: 0x9E3779B97F4A7C15 (~273), next_prio (~950).
Problem: every insert creates one fragment with a predictable priority, so a peer can order its inserts to make the treap a path: depth 39,998 at 40k inserts, and every later get / seek / position_of / cmp_sweep on that replica is O(n). (2026-09-24 review.)
Fix: seed per replica from a random source, or derive priorities from a keyed hash of the slot. Perf-gated (item 11's run-index rule).
Where: src/hashseq.rs split_run_at (~943) relocates every element of the right part; src/run_index.rs Frag::split_bits (~159) copies Bits::Large one bit at a time and keeps the left piece in place.
Problem: forking left-to-right through a long run is O(n²) (40k chars: 6.4 s); Before inserts marching forward through a large fragment likewise (40k: 5.5 s vs 0.1 s in reverse). Honest-reachable, peer-triggerable. (2026-09-24 review.)
Fix: relocate the smaller side; shift bitmap words, not bits.
Where: src/encoding.rs force-emit victim scan over blocked (~1282); the fork-extender minimum recomputed per child (~852) and per remove link (heads_pinning, ~971-987).
Problem: k soft cycles cost O(k²) (8k cycles: 0.6 s); F fork children of one element cost O(F²) (16k: 2.5 s to encode a 144 KB snapshot). Strict decode re-encodes, so it inherits both. (2026-09-24 review.)
Fix: keep hard-ready blocked blocks in an ordered set keyed by (depth, idx); memoize the extender per parent.
Where: src/hashseq.rs live_set (~1557), under marks_at / marked_spans.
Problem: overwrites.iter().any(..) makes each read O(k² · W) for k marks naming W ids (k = W = 1000: 326 ms per marks_at). Related: honest mark toggling grows overwrites quadratically on the wire (MARKS.md open problem 1). (2026-09-24 review.)
Fix: SortedIdVec::contains (binary search), or one suppressed-id set per kind group.
Where: src/delivery.rs orphaned; src/hashweb.rs store-level orphaned.
Problem: nodes waiting on a ref that never arrives (or was refused) are kept forever, re-applied on merge, and dropped only by encode. Memory is linear in attacker input, with no bound. (2026-09-24 review.)
Fix: decide a policy — per-object / per-peer caps, age-out, or drop-on-encode made explicit.
Where: src/encoding.rs decode_hashseq / decode_hashkv / decode_hashweb (non-strict); decode_hashweb object sections (insert, not merge); wasm applyTo ignores consumed length.
Problem: trailing garbage is accepted silently, and a duplicated object section replaces the earlier one (a full section followed by an empty one decodes to empty text). Strict mode catches both. (2026-09-24 review.)
Fix: reject trailing bytes everywhere; merge or reject duplicate object sections.
Where: src/hashkv.rs put_ids, src/hashweb.rs provide_value.
Problem: a kv_mut().put_ids(k, vid) whose value was minted only via web.provide_value stays pending in the authoring replica's own kv view: web.resolve sees it, every decoding/merging peer hydrates it, but the local kv.get does not. The wasm and test or_else(web.resolve) fallbacks exist only for this case.
Fix: hydrate the kv view from web.values on put_ids (or give the kv a handle to the shared store), then delete the or_else fallbacks.
Where: src/hashkv.rs read_id (~183-197).
Problem: two concurrent del(k) → Conflict([TOMBSTONE, TOMBSTONE]), get None, keys() lists the key as live. Spec-conformant but useless to the app.
Fix: dedup value ids in read_id. Needs a HASHKV_SPEC decision first.
Where: src/hashweb.rs:269 knows, the store-orphaned dedup.
Problem: both scan the orphaned Vec linearly, so N orphaned envelopes on one unopened object cost O(N²).
Fix: key orphaned by node id, or keep a side set of ids per object.
Where: src/hashkv.rs:413.
Problem: assert_eq! on origin. HashSeq::merge has the same assert but wasm guards it (merge_encoded); the kv path is Rust-API only.
Fix: return an error, or document the precondition and keep the assert.
Where: src/value.rs:123.
Problem: returns None for unknown kinds, so resolve cannot tell "unknown value kind" from "artifact not yet received".
Fix: a distinct Unknown(kind) variant or a Result.
Where: src/hashweb.rs:8 vs tests.
Problem: disagreement on whether a link payload is the origin or the object id.
Fix: pick one, fix the other.
Where: src/hashweb.rs apply_to_with_id (~313) and the module docs ("one object's ops can never merge into another"); HASHWEB_SPEC.md "the envelope needs no trust".
Problem: a child opened at parent op X has origin X, which is also an ordinary element of the parent, so any op whose refs are ⊆ {X} ∪ child ops is valid in both objects; the untrusted envelope picks which. Confirmed: child text re-enveloped into the parent ("abEVIL"), a child put into the parent kv, a parent put into the child, and the child's birth Place into the parent's placement register (can manufacture containment cycles or freeze a register). Per-object convergence holds; integrity and attribution do not. (2026-09-24 review.)
Fix: decide — a per-object domain separator in the preimage (commit each op to its object), or state in the spec that parent and child share one commitment domain at X.
Where: src/hashkv.rs hydrate (~162); src/hashweb.rs provide_artifact_bytes (~239), merge (~352).
Problem: store artifacts are mirrored into a kv only when a node is delivered; bytes that arrive later (0xAF frames, HashWeb::merge) never reach kvs that already exist. Replica A (artifact then op) reads Some, replica B (op then artifact) reads None, yet A == B. A snapshot round-trip heals it; wasm and nool read the web store first. Mostly moot for values ≤ 15 bytes (identity-form ids resolve without the store). (2026-09-24 review.)
Fix: resolve kv reads through the web store, or re-hydrate kvs when new artifacts arrive.
Where: src/placement.rs (register + chain() only); web/kb.js approximates it.
Problem: HASHWEB_SPEC / CYCLE_REVERT.md specify cyclic SCCs detach, flagged; the core has no implementation, and kb.js checks only chain[0] instead of falling back along the chain. chain() itself is O(n³–n⁴) (closure recomputed inside maximal's double loop: 400 Place ops → 4.4 s per read). Item 56 lets a peer manufacture the cycles. (2026-09-24 review.)
Fix: implement D4 in the crate; memoize closures in chain() (or compute maximal elements in one reverse-topological pass).
Where: web/kb.js, web/index.js.
Problem: unverified: offsetOfPoint / locateOffset DOM mapping after the code-point conversion layer, IME event ordering with the deferred render, sidebar drag resolving by origin at drop, the CodeMirror listener in web/index.js, and the title debounce capturing its page.
Fix: drive the KB in a browser and check each path: astral chars ("😀ab" Backspace-merge, replacing 😀 with 😁), IME composition during a remote delta, drag during a remote render, title edit then page switch within 350 ms.
Where: src/wasm.rs ~1050-1140.
Problem: an invalid call still pushes kind/value artifacts. Harmless.
Fix: validate first.
Where: web/kb.js connectSync, sync-server/src/main.rs client_loop.
Problem: every connect uploads a full snapshot and the server answers every join with one.
Fix: item 39.
Where: web/kb.js connectSync / handleSyncMessage, sync-server/src/main.rs client_loop.
Problem: the library has everything for a snapshot-free handshake (encode_frontier / decode_frontier, per-peer HashWebClock, deltas_for, HashWeb::clock) but the wire protocol still opens with full snapshots both ways: the server sends fresh_bytes() on join, the client sends snapshotBytes() on open, and the lagged path resends a snapshot. Clocks are values that change only when the peer states its clock or when we send, so a delta the client receives from the relay is not in the relay's clock and ships back on the next drain (the relay dedups, then re-broadcasts it): steady state needs the peer's clock to travel with its deltas, or the relay to answer each delta with its clock.
Fix: on open the client sends its 0xC1 frontier; the server keeps a HashWebClock per connection from the frame, replies with deltas_for (a delta, or nothing) plus its own 0xC1 so the client can answer with its delta; each 0xDE frame carries the sender's frontier (or is followed by a 0xC1) so the receiver replaces the sender's clock on every delta; after sending, each side keeps its own clock() as the peer's; lagged clients get a fresh frontier exchange instead of a snapshot. Keep the snapshot path for legacy clients (first frame HWB2). The sync-server's wire_stale snapshot cache is then only needed for the compat path.
Where: src/bin/nool/main.rs println! sites.
Fix: write through a locked stdout and ignore ErrorKind::BrokenPipe, or reset SIGPIPE at startup.
Where: src/bin/nool/main.rs:28 USAGE.
Problem: the per-command usage strings in repo.rs:525,610 mention --force on rm and merge; the top-level text does not.
Fix: add the flags to the top-level text.
Where: src/bin/nool/repo.rs init, tracked_in_cwd.
Problem: init writes store before root; tracked_in_cwd turns a stray .nool entry into file name "". Unverified whether the atomic-save and safe_key changes covered these.
Fix: check; fix or drop.
Where: src/bin/nool/repo.rs Repo::load … save; src/bin/nool/sidecar.rs load_seq … store_seq.
Problem: two concurrent invocations both load, and the last save wins. A merge/apply whose save is lost has already rewritten the working tree, so the next commit records the merged text as local inserts — duplicated on the next merge with that peer. (2026-09-29 nool review.)
Fix: an exclusive lock file (.nool/lock, <file>.nool.lock) held from load to save.
Where: src/bin/nool/repo.rs scan_untracked, stage.
Problem: the scan descends into target/, node_modules/ and the like; with any tracked file missing, stage diffs it against every untracked file for move detection. A code checkout is read in full on every status. (2026-09-29 nool review.)
Fix: an ignore file (.noolignore), or at least skip common build directories.
Where: basecamp/ui/src/HashwebView.qml ~1936-1952, basecamp/rust-lib/src/cursor.rs.
Problem: the QML ignores authority while localEdits > 0, which never resets while a peer is also editing. "hello": A types at the end while B inserts "XYZ" at 0 → text_insert(5,"!") → "XYZhe!llo". cursor.rs exists for this and is unused.
Fix: route typing through cursor_insert / backspace / delete, or apply authority with id-based caret restore.
Where: basecamp/rust-lib/src/module.rs ~343-351, bridge.rs ~171-198, space.rs ~195-209.
Problem: a lost mid-size artifact frame is never retransmitted; once a space's ops snapshot exceeds the 120 KB frame cap, anti-entropy stops and a fresh peer never bootstraps (visible in status, not fixed). Overlaps item 17.
Fix: chunk snapshots; retransmit or lazily fetch artifacts on Read::One(id) misses.
Where: basecamp/rust-lib/src/space.rs ~148-154.
Fix: encode under the lock, write outside it.
Where: basecamp/rust-lib/Cargo.toml:25.
Problem: pinned to 5d3bf5b. When the pin moves: mark_range / move_element / unmark_range return Result<HashNode, HashNode> (breaks lib.rs:611,631,649,466), doc.rs:38-56 should use anchor_id_at, module-side artifact tracking should switch to web.take_new_artifacts(), and enable_outbox / take_deltas are gone: SpaceState must own a hashseq::HashWebClock for the topic: deltas_for(&clock) then clock = web.clock() in drain_deltas, clock = other.clock() before merging a snapshot in merge_frame; the recent_sent echo filter and the "outbox" comments in space.rs / cursor.rs go with it. The local file:// git source must become the github URL once master is pushed (comment at :22).
Fix: bump the pin in one change with those adaptations; rebuild via the lgx-portable variant and restart the app (factory dylib).
Where: sync-server/src/main.rs.
Problem: anyone reaching the port can write. Caps exist (4 MiB ws message, 2 MiB artifact, HASHWEB_MAX_ARTIFACT_BYTES 512 MiB, HASHWEB_MAX_OBJECTS 200k, 256 new objects per delta). Prod is on a public IP.
Fix: shared token, origin allowlist, or accept open-write for the devnet.