urnetwork/build v2026.9.11-1043550030

on GitHub

Changes in v2026.9.11-1043550030

v2026.9.10-1042581110 ... v2026.9.11-1043550030 -- 106 commits across 9 components.

android

urnetwork/android 446673c21...164a1562b

• update (164a1562b)

apple

urnetwork/apple 03ca14c11...533d5b399

• Pro celebration: pixelate a window snapshot on macOS too (533d5b399)
  The macOS branch of ProScreenSnapshot returned nil, so the celebration flew confetti over an unfiltered screen. Draw the key window's content view into a bitmap at the backing scale with cacheDisplay and hand it to the same snapshot mosaic iOS uses.
• Pro celebration: pixelate a snapshot of the screen, not the clear overlay (ea9131f6a)
  Since the celebration moved onto a clear overlay (the pixelation is a raster-layer filter, and the UIKit-backed tab view under it cannot be rendered into that layer without the unsupported-view placeholder), the mosaic had nothing to sample: the confetti flew over a sharp screen.

windows

urnetwork/windows 43d3167d7...ed9a7cb3b

• Pixelate a window snapshot under the Pro celebration instead of the acrylic veil (ed9a7cb3b)

build

urnetwork/build bcb80e165...f667cf5a6

• 2026.9.10-1042581110 restore android pin (f667cf5a6)

sdk

urnetwork/sdk 552c023b8...6337f4e54

• Subprotocol stats: mirror the query counters and expose the per-id received count (6337f4e54)
• Expose subprotocols on the device: enable by id, raw listeners, send, query, stats (e0a0d6758)

connect

urnetwork/connect 8e46dde54...cba4ea17a

• FLIGHTGATEFIX.md: Phase 0 matrix, device baseline, third report, PRs become the base (99556e3a6)
• FLIGHTGATEFIX.md: fold in the full throughput report and review PRs 208 and 209 (76abd8124)
  The second report supplies rig evidence for four of the six mechanisms and two upstream PRs. Records what each PR changes, the RTO release that grows the window, the ack policy that reverses LOWBAR's measured ack affinity on mobile, the low-bar regime the gate change reaches, the tun bound that leaves the reentrancy in place, and the missing failure tests; restructures the candidates one per mechanism with gates.
• FLIGHTGATEFIX.md: peer review of the unreliable flight gate report and a research plan (861001616)
  Confirms the route-wide admission gate against per-lane flight accounting, then names four untested mechanisms that produce the same trace: acks pinned to the p2p lane, cross-carrier reordering read as loss, RTP fragment loss amplification, and a fast path with no liveness. Lists the deterministic tests that decide each hypothesis, the missing mixed-carrier PERFVAR campaign, the counters to add first, and how each fix candidate is judged.
• transfer: defer a timeout resend while cumulative ACKs are still advancing (9f09f848e)
  With a direct datagram lane and the relay lane both active, the relay lane suffered spurious-RTO cascades: the sequence's scaled RTO (2x mean RTT, floor 300 ms) sits below the relay's queue-inflated round trip, so a whole window of relay-carried items times out and is re-sent while their ACKs are still in flight. The resends add load, which adds delay, which fires more timeouts. Measured on the provider as bursts above 1,000 timeout resends per 2 s, recurring every 2-4 s for as long as the ...
• transfer: end-to-end regressions for the unreliable-lane gate and the ACK lane (124f48d7f)
  The unit tests around the flight-gate fix exercise the predicates directly. These two drive the real Client send and receive pumps over in-memory routes, so they fail on stock with the exact shape of the field failure rather than on an internal invariant.
• transfer: mixed-lane recovery — stop gap-resending relay items that are merely behind the direct lane (51cb08b91)
  With a direct datagram lane (WebRTC fast path, ~20 ms) and the relay carrier (150-300 ms) both active, an ordered stream is striped across the two. Every relay-carried item is routinely acknowledged after three or more later items that rode the direct lane, which selective-ACK gap recovery read as a hole and re-sent at once: 1,000-2,800 gap resends per 2 s on the provider while p2p was live, i.e. the relay's traffic doubled by copies of packets that were only late. The same mixing fed the ...
• transfer, p2p: keep ACKs off the unreliable lane and size the ICE UDP socket buffers (e50b4b38a)
  With the flight-gate fix in place, a live p2p route still cost the pinned provider most of its throughput: the client's cumulative ACKs for p2p-delivered packets were sent back with p2p carrier affinity, and the provider's kernel UDP receive buffer (Linux default ~208 KB; connect never set SO_RCVBUF on the ICE sockets) dropped thousands of them per run (Udp6RcvbufErrors +934 / +5261 / +7916 in three p2p-live runs). Each lost cumulative ACK timed out the sender's whole 2 MiB window ...
• transfer: never let a full unreliable flight stall a sequence that has a reliable carrier (4c47ef2bc)
  Root cause of the "pinned provider collapses to ~1 Mb/s / 0 and never recovers" report. When a p2p (WebRTC datagram fast path) route joins the h1 relay route, items first carried by the unreliable lane are tracked in the sequence's unreliable flight (sendFlightController). canSendForKey() gated every send of the sequence — h1 included — while byteCount >= byteLimit, and an RTO only halved the limit (floor 8 KiB / 8 messages) without releasing the lost items. On a lossy p2p carrier the ...
• Wait for processed client key registration before tunnel admission (eb163c007)
• tun: reproduce the injecting-reader deadlock through the real stack (54546839a)
  The existing tests cover the bounded wait at the link endpoint. This one reproduces the deadlock that motivated it: the goroutine draining the tun's outbound queue is also the one injecting inbound packets, and the injected packet provokes a reply netstack writes back into that same full queue.
• tun: bound the netstack outbound-queue wait so an injecting reader cannot deadlock the stack (c109440ac)
  tunLinkEndpoint.WritePackets waited without bound for space in the outbound (tun read) queue. The goroutine that drains that queue can itself be inside an inbound injection: the socks client's tun reader calls SendPacket, the multi-client synchronously hands a race-buffered response to the receive callback (ip_remote_multi_client.go:6798), the callback writes it into netstack, and netstack answers it (a RST for a closed flow) by writing back to the tun. That write waits for the queue this ...
• SUBPROTOCOL.md: the retain helper's name in the proposal section (16090f2c3)
• SUBPROTOCOL.md: RetainSubprotocolBytes takes the bytes and returns a pooled copy (8aab4db67)
• Client.receive: an empty batch still reaches the callbacks (d5481bc76)
  The subprotocol dispatch only runs on a non-empty batch, and only a batch that was made entirely of subprotocol frames and queries ends there. The receive hook had returned early on any empty batch, which skipped the callbacks for the nil batch two inline-dispatch tests hand in directly.
• Docs: SUBPROTOCOL.md is implemented; DESIGNNOTES.md gains the layer (aa7a40368)
  The design document drops "proposal" from its title and its status line names the four commits. The layered model in DESIGNNOTES.md lists subprotocol.go as the layer where user protocols ride as frames.
• Subprotocols end to end over the in-process transports (91d88278a)
  Two clients on the gateway transports of transfer_test.go: a hand-rolled codec and a ProtoCodec of SimpleMessage from a to b, a raw listener alongside the typed handler seeing the same messages in order, an unregistered id dropped and counted, a plain frame delivered after them, the sender and receiver counters, the peer query answered over the companion reply, and the old-peer case where the receiver has forgotten its registry: the subprotocol frames drop, the sequence keeps delivering.
• Client.receive hands subprotocol frames and queries to the registry first (492f0bbdd)
  The dispatch runs ahead of the generic receive callbacks, inline on the receive goroutine like every frame today: subprotocol frames go to their raw listeners and typed handler, the two query frame types are answered or completed, and the compacted rest of the batch reaches the application callbacks as before. A batch left empty returns early. The sequence layer is untouched.
• Subprotocols: codec, registry, dispatch, sends, peer query and stats (b34042daa)
  The user-facing side of SUBPROTOCOL.md §10 in one file. A subprotocol is an id and a codec (Size, MarshalAppend, Unmarshal, the Go protobuf shape; a ProtoCodec adapter covers any protobuf message, and a codec may own its instances through New/Release). A send takes one pool buffer of exactly the wrapper size, writes the SubprotocolMessage header by hand and lets the codec append the payload in place, byte-identical to proto.Marshal; a codec whose Size disagrees with what it wrote is ...
• protocol: the subprotocol message and the peer subprotocols query (4eaba5b5c)
  Adds the three messages of SUBPROTOCOL.md §10.1 and their frame types: Subprotocol (30) carrying a SubprotocolMessage{subprotocol_id, message_bytes} whose payload a registered codec decodes in place, and the TransferSubprotocolsQuery/Result pair (31, 32) that lets a peer ask which subprotocols another can receive. The message carries a Message suffix because a proto3 enum value shares the package scope with message names. ToFrame/FromFrame gain the generic cases; the hot path in ...
• SUBPROTOCOL.md: review notes and the companion reply of the peer query (040af21dc)

warp

urnetwork/warp 6544fe135...61f9a55c9

• Gate Grafana publishers on child readiness (61f9a55c9)

sn

urfoundation/sn 3a042dabc...bed0fe4f9

• Make server test fixtures portable (bed0fe4f9)
• Keep provisional payout cohort diagnostics separate from API failures (8744f44a0)
• Use recorded V2 receipts for provisional epoch completion (54dccbda1)
• Handle absent native storage and record settled testnet usage (b2895a5fb)
• Observe provisional validator intents from the retained V2 state (d455b10da)
• Canonicalize validator contract addresses before measurement production (2b22fb192)
• Record actual runtime recovery in the shortened testnet plan (b653ff83f)
• Exclude local replay work from attempt stream HTTP timeout (67bdfc7f0)
• Prioritize the running epoch scenario in testnet execution plan (793610746)
• Retain original EVM recovery checkpoints through finalization (69410c2ca)
• Keep conformance drills out of provisional traffic startup (88eb0611f)
• Resume provisional campaigns through unlimited owned RPC (732fe11d0)
• document canonical competition patches (582e4a38f)
• Reuse authenticated parent deployment payloads during provisional campaign (45cc59bc2)
• Give provisional boundary reads their bounded shared preparation budget (eb344cc0d)
• Reuse native campaign connection and retain closed measurement inputs (74b1bf9d2)
• Reuse live provisional receipts at scenario entry without repeating doctor (9b59927a3)
• Keep initial trail registration across step waits and waive provisional publication gate (79c527827)
• Observe fresh proofs during provisional campaign instead of blocking launch (d3125920e)
• Run provisional testnet with retained staging authority and partial providers (c6de16048)
• Keep provisional provider startup running through slow readiness (a57f4a5b3)
• Record archive preparation as waived for provisional campaigns (681ad8cb5)
• Resume provisional validators from completed local recovery and publication records (8b9368c46)
• Tolerate brief empty argv observations during child startup (01b8c1f8c)
• Reuse retained historical observations during provisional validator startup (4299079da)
• Read claim discovery epoch independently of optional chain settings (6bf920e67)
• Resume provisional validators from retained activation and coordinator history (cc695b1a3)
• Resume retained validator namespaces and tolerate recovered provisional restarts (4540ae8e7)
• Keep provisional testnet runs alive through log findings (a22168636)
• Resume authenticated validator disk state without legacy migration (0cb0f2aca)
• Lock the live testnet resume correction (2ead69c81)
• Resume closed activation attempts and prioritize live testnet execution (a7d7fbe4c)
• Lock the repaired validator evidence source and record recovery (66a1f1590)
• Honor transition limits for typed validator evidence (6b442d1a7)
• Allow the measured serial custody race census to finish (36c638dce)
• Freeze the reviewed testnet release lock and resume handoff (909c8c6d9)
• Track current Subtensor deployment files in the release lock (26b1ced91)
• Resume completed activation setup with signed provider wallets (8951baf38)
• Split simulator evidence owners and record provisional progress (e76a0e696)
• Record incomplete finalization evidence and remaining acceptance work (bc7dd7e0c)
• Reuse processed tunnel registrations across validator requests (a0c082d79)
• Prepare pinned validator tunnel before sending verify traffic (6a8ebde22)
• Use normal control routes for loopback HTTP operators (5fb408d89)
• Align validator control timeouts with provider registration (ac888985f)
• Defer closed native inputs explicitly in provisional testnet runs (0eaac9c4e)
• Require processed identity keys for validator tunnel clients (03579c352)
• Preserve shared attempt preparation across trail timeouts (e8a73014e)
• Reuse successful provisional admission history across refreshes (c42d8a9b6)
• Skip repeated doctor for verified no-spend live resume (1e38b3846)
• Allow explicit seeded admission discovery for provisional testnet (206258ab1)
• Report retained validator admission refresh failures (0bb6235a2)
• Adopt live topology during provisional testnet resume (761578612)
• Allow testnet swarm registration to wait for chain observations (728fe0eaf)
• Stage provisional provider startup within the shared RPC quota (18482b9c2)
• Allow synthetic wallet compatibility in provisional testnet resumes (8079bd051)
• Allow provisional testnet resume with authenticated completed work (6414df77c)
• Persist verified historical audits across executor restarts (79022715f)
  Authenticate exact immutable proofs and retain fresh chain and local evidence checks. Preserve successful install reads before later receipt failures and retry interrupted read-only EVM response bodies within the existing bounds.

server

urnetwork/server a87ec1b62...ce6d26e2e

• Clarify stale client rollout evidence (ce6d26e2e)
• Add service observability and subscription monitoring (907c72004)
• Fix provider key publication monitoring (5cf417d4a)
• Harden monitor root-cause diagnostics (7ff0219bc)
• Drain provider blackhole probes independently (785f8084c)
• Fix Connect daily onboarding event writes (d0d30a0fa)
• Require coherent proxy pool metric snapshots (652fd5eb5)
• Document Grafana publisher readiness failures (f5b37eeed)
• Reject undersized reserve moves and reconcile expired unsigned deposits (4ff898076)
• Use the server logging module for artifact stream diagnostics (36f73e620)
• Recover expired epoch closes and keep bounded evidence streams readable (d0cdededd)
• record staging evaluator capacity (cf796ee06)
• fix evaluator scorer repository trust (1771f2b68)
• Batch transaction fee preparation to avoid repeated RPC queue waits (0de2125e4)
• Seed historical provider attribution fixtures without current membership assumptions (4b8c3303f)
• Diagnose Subtensor peer loss (9766c1175)
• Verify monitor binaries are executable (d707a7a2e)
• Use canonical Subtensor deployment runner (26690ed52)
• Use current Connect cleanup revision (7ea9bae08)
• Classify onboarding app-open attribution failures (fd1f0b296)
• Track onboarding email engagement (0aac4806b)

Filtered out of this changelog: 5 merge commits (both sides are already listed), 1 version-stamp commit written by all/run.sh on every release, 1 ungoogle re-tag commit written by all/run.sh. Re-run all/changelog.py --from v2026.9.10-1042581110 --to v2026.9.11-1043550030 --filters= to include them.