crowdypy 0.28.0.dev1__tar.gz → 0.30.0.dev1__tar.gz

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/AGENTS.md

@@ -131,7 +131,10 @@ idle timeout, with `COMMAND_SESSION_RELEASED` reason 5. CrowdyCPP verifies and h
 connection reports `ConnState.INACTIVE` (6), which nothing reconnects; a game calls
 `client.udp.connect()` on the player's next input. Status rows carry the state as a number, so
 `ConnState` must name every value CrowdyCPP's `replication::ConnState` has or `ConnState(...)`
-raises. Since 0.27.0 (CrowdyCPP 0.79.0) an idle release within `idle_release_guard_ms` (60 s) of
+raises. Since 0.29.0 (CrowdyCPP 0.81.0) a capabilities message carries the assignment's control
+nonce and a v0.45.0 server sends the bound 44/45 forms: a test that wants a final bound release reads
+the nonce from the client's CLIENT_CAPABILITIES (`test_replication.py`, `bound_release`). Since
+0.27.0 (CrowdyCPP 0.79.0) an idle release within `idle_release_guard_ms` (60 s) of
 the client's own gameplay input reconnects instead (a captured release frame verifies again);
 a test that wants a final release teaches the fake server the address with a heartbeat, not an
 actor update.
@@ -243,6 +246,13 @@ The replication system saturates the local network stack, so the binding
   16x16x16 one-byte grid cannot hold goes to `ChunkData::overlay`.
 - Do not write voxel types or states into the dense grid from Python. That bypasses the
   overlay, and the echo matching of local edits.
+- Since 0.30.0 (CrowdyCPP 0.82.0) the native store paces and undoes edits; the binding turns its
+  own I/O thread, reloads and reconnect catch-up off (`ioThread`, `reloadReplacedChunks`,
+  `catchUpOnReconnect` false), because the facade reads the durable store itself and runs
+  `catch_up` and the reload of a replaced chunk. A refused, unsent or timed-out edit reaches the
+  facade as an `EDIT_REFUSED` event row (`a` packs x/y/z as 16-bit fields, `c` the result,
+  `restored` and the error code, `epochMs` the edit id). Read a chunk through `forEachState`,
+  `forEachOverlay` and `grid()`: `ChunkData` keeps no public maps any more.
 - The voice helpers (`native/voice_binding.cpp`) bind CrowdyCPP's `voice_frames.hpp`.
   `crowdypy.media` checks every argument as CrowdyJS does first, because CrowdyCPP clamps the
   options CrowdyJS refuses.

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/MIGRATION.md

@@ -3,6 +3,54 @@
 CrowdyPy is pre-1.0. Within a minor line, patch releases keep source compatibility; each
 new minor may change the API. Read the section for every minor you skip.
 
+## 0.30.0
+
+CrowdyJS 18.30.0 and CrowdyCPP 0.82.0 (the ChunkStore rework). Box reads and `since` need ck-api
+v2.67.0. **Breaking** for code that keeps `set_voxel()`'s return value or relies on a realtime
+edit being written back.
+
+- **`ensure_around` reads only what the store does not hold**, as boxes (`lowChunk`/`highChunk`)
+  read in pages of the size the server applied; a chunk two pages return is applied once
+  (`duplicate_page_chunks`). A step along one axis at range 8 reads the 289 chunks it uncovers.
+  Range 0 reads one chunk. `CachedChunk` has `voxel_states_truncated` and `stored_at`.
+- **`set_voxel()` returns an edit id, is paced, and is not written back.** At most
+  `max_edits_in_flight` (128) are unanswered and `max_edits_per_second` (250) go out a second
+  (`chunk_options`); the rest wait, already shown (`queued_edits`, `edits_in_flight`). The server
+  records realtime edits, so the chunk is no longer queued for write-back (it was, whole).
+- **A refused edit is undone.** One the server refuses, the connection does not take, or whose
+  echo does not come back within `edit_timeout_ms` (10 s) puts the voxel back and reaches
+  `on_edit_refused` as a `VoxelEditRefusal` (`reason` `refused`, `not_sent` or `timeout`,
+  `restored`, `error_code`, `edit_id`).
+- **A replaced chunk is read again** (`chunk_changed`, `reload_replaced_chunks`), and a seed queued
+  for write-back gives way to it. **After the connection comes back**, `catch_up(since)` reads the
+  last area's rewritten chunks and those with edits since 30 s before the drop
+  (`catch_up_on_reconnect`).
+- A hydration replaces the chunk's states and overlay with the stored copy's and keeps this
+  client's unanswered edits over it (the native store's rule since CrowdyCPP 0.82.0).
+
+## 0.29.0
+
+CrowdyJS 18.29.0 and CrowdyCPP 0.81.0. It needs nothing new on the tier; the bound frames and
+`chunk_changed` come from replication servers v0.45.0.
+
+- **A server's reconnect command is honoured.** The native verifier had computed the HMAC of
+  `COMMAND_RECONNECT` (22) over the type byte and the game token, while the replication servers
+  sign the type byte alone, so no reconnect command ever verified: each counted in
+  `stats()["hmac_failures"]` and the client stayed until its watchdog moved it.
+  `wire.verify_command_reconnect` checks the servers' form.
+- **Reconnect and release frames are bound to the assignment.** Each assignment draws a random
+  8-byte nonce, which the capabilities message carries; a v0.45.0 server sends
+  `COMMAND_RECONNECT_BOUND` (44) and `COMMAND_SESSION_RELEASED_BOUND` (45) with it inside the
+  HMAC. One carrying another assignment's nonce, captured earlier and sent again, is dropped and
+  counted in `stats()["stale_bound_control"]`. A verified bound idle release is final at once;
+  `idle_release_guard_ms` applies only to the legacy 28, which older servers and the Game API's
+  relay still send (the client cannot tell an older server from a replay, so it still accepts
+  them).
+- **`chunk_changed`** (handler name, `MessageType.CHUNK_CHANGED_NOTIFICATION`, 146): a chunk near
+  the player was replaced as a whole by a hub's or mod's `world.set_chunk`;
+  `notification.updated_at_ms` is its new `updatedAt`. Read it again. It arrives with or without a
+  world session attached.
+
 ## 0.28.0
 
 CrowdyJS 18.28.0 and CrowdyCPP 0.80.0. **It needs ck-api v2.67.0**: `game_apps.nearby_grids()`

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crowdypy
-Version: 0.28.0.dev1
+Version: 0.30.0.dev1
 Summary: Official Python SDK for Crowded Kingdoms: typed GraphQL clients and a native UDP replication core
 Keywords: crowded-kingdoms,multiplayer,replication,graphql,sdk,udp
 Author: Crowded Kingdoms
@@ -51,6 +51,10 @@ CrowdyPy follows the [CrowdyJS](https://github.com/CrowdedKingdoms/CrowdyJS) API
 client, bound with [nanobind](https://github.com/wjakob/nanobind) and shipped inside the
 wheel. Python never touches a datagram.
 
+**v0.30.0: the ChunkStore rework.** `ensure_around` reads only what is missing, as boxes, paged; `set_voxel` is paced and returns an edit id, and an edit the server refuses or never echoes is undone (`on_edit_refused`); a replaced chunk is read again and a reconnect catches up; realtime edits are no longer written back. CrowdyJS 18.30.0 and CrowdyCPP 0.82.0. See [MIGRATION.md](MIGRATION.md).
+
+**v0.29.0: reconnect commands verify, bound control frames, and `chunk_changed`.** A server's `COMMAND_RECONNECT` verifies again; against replication servers v0.45.0 the reconnect and release frames carry a per-assignment nonce under their HMAC, so one captured earlier is refused (`stats()["stale_bound_control"]`); `chunk_changed` reports a chunk a hub's or mod's `world.set_chunk` replaced. CrowdyJS 18.29.0 and CrowdyCPP 0.81.0. See [MIGRATION.md](MIGRATION.md).
+
 **v0.28.0: region reads.** `chunks.by_distance()` and `voxels.list_by_distance()` take a box (`lowChunk`, `highChunk`) as well as a cube, pages are stable and answer the paging applied, `since` filters a chunk read, `voxels.list()` pages, and `game_apps.nearby_grids()` returns your own `permissionKeys`. Needs ck-api v2.67.0. CrowdyJS 18.28.0 and CrowdyCPP 0.80.0. See [MIGRATION.md](MIGRATION.md).
 
 **v0.27.0: a replayed idle release cannot end a playing player's session.** An idle release that arrives within a minute of this client's own gameplay input reconnects instead of going `ConnState.INACTIVE` (`idle_release_guard_ms`, counted in `stats()["idle_releases_after_input"]`), and a reassignment left over from the session that ended no longer reassigns the next one. The native chunk store keeps unechoed local edits over a stored copy. CrowdyJS 18.27.0 and CrowdyCPP 0.79.0. See [MIGRATION.md](MIGRATION.md).

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/README.md

@@ -11,6 +11,10 @@ CrowdyPy follows the [CrowdyJS](https://github.com/CrowdedKingdoms/CrowdyJS) API
 client, bound with [nanobind](https://github.com/wjakob/nanobind) and shipped inside the
 wheel. Python never touches a datagram.
 
+**v0.30.0: the ChunkStore rework.** `ensure_around` reads only what is missing, as boxes, paged; `set_voxel` is paced and returns an edit id, and an edit the server refuses or never echoes is undone (`on_edit_refused`); a replaced chunk is read again and a reconnect catches up; realtime edits are no longer written back. CrowdyJS 18.30.0 and CrowdyCPP 0.82.0. See [MIGRATION.md](MIGRATION.md).
+
+**v0.29.0: reconnect commands verify, bound control frames, and `chunk_changed`.** A server's `COMMAND_RECONNECT` verifies again; against replication servers v0.45.0 the reconnect and release frames carry a per-assignment nonce under their HMAC, so one captured earlier is refused (`stats()["stale_bound_control"]`); `chunk_changed` reports a chunk a hub's or mod's `world.set_chunk` replaced. CrowdyJS 18.29.0 and CrowdyCPP 0.81.0. See [MIGRATION.md](MIGRATION.md).
+
 **v0.28.0: region reads.** `chunks.by_distance()` and `voxels.list_by_distance()` take a box (`lowChunk`, `highChunk`) as well as a cube, pages are stable and answer the paging applied, `since` filters a chunk read, `voxels.list()` pages, and `game_apps.nearby_grids()` returns your own `permissionKeys`. Needs ck-api v2.67.0. CrowdyJS 18.28.0 and CrowdyCPP 0.80.0. See [MIGRATION.md](MIGRATION.md).
 
 **v0.27.0: a replayed idle release cannot end a playing player's session.** An idle release that arrives within a minute of this client's own gameplay input reconnects instead of going `ConnState.INACTIVE` (`idle_release_guard_ms`, counted in `stats()["idle_releases_after_input"]`), and a reassignment left over from the session that ended no longer reassigns the next one. The native chunk store keeps unechoed local edits over a stored copy. CrowdyJS 18.27.0 and CrowdyCPP 0.79.0. See [MIGRATION.md](MIGRATION.md).

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/docs/compatibility.md

@@ -5,7 +5,7 @@ are in `pyproject.toml` (`[project].version`, `[tool.crowdypy.crowdyjs]`,
 `[tool.crowdypy.crowdycpp]`); `tests/unit/test_release_versions.py` refuses this page when
 its version disagrees.
 
-- CrowdyPy `0.28.0`
+- CrowdyPy `0.30.0`
 - API surface: CrowdyJS (the pinned version and commit in `pyproject.toml`); the generated
   `docs/parity-matrix.md` lists every covered method, every native equivalent and every
   browser exclusion with its reason. The gate is strict: there are no portable gaps, and a

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/docs/parity-matrix.md

@@ -4,14 +4,14 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 
 ## Target
 
-- CrowdyJS: `18.28.0` at `bc8b2b0737c0caf1486358c721123fa72fc1b955`
-- CrowdyCPP (native core): `0.80.0` at `d0d95975d6a6bcf1e08c3fd1cbde4a8be433b062`
+- CrowdyJS: `18.30.0` at `4840d76029ffb15a6de6232dab9336f2e9ab6514`
+- CrowdyCPP (native core): `0.82.0` at `c6875412bcea97120b4540b80d9b34504c29acf9`
 - schema.gql identical to CrowdyJS's: yes
 - Gate mode: strict portable parity (every portable gap is release-blocking)
 
 ## Summary
 
-- Covered: 1475
+- Covered: 1480
 - Portable gap: 0
 - Native equivalent: 47
 - Browser exclusion: 128
@@ -792,6 +792,9 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `ChannelsAPI.unban` | covered |
 | `ChannelsAPI.update` | covered |
 | `ChannelsAPI.updateRole` | covered |
+| `ChunkStore.catchUp` | covered |
+| `ChunkStore.duplicatePageChunks` | covered |
+| `ChunkStore.editsInFlight` | covered |
 | `ChunkStore.ensureAround` | covered |
 | `ChunkStore.flush` | covered |
 | `ChunkStore.get` | covered |
@@ -799,9 +802,11 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `ChunkStore.list` | covered |
 | `ChunkStore.markDirty` | covered |
 | `ChunkStore.onChunkChanged` | covered |
+| `ChunkStore.onEditRefused` | covered |
 | `ChunkStore.onWriteBackFailed` | covered |
 | `ChunkStore.pendingWriteBacks` | covered |
 | `ChunkStore.pruneBeyond` | covered |
+| `ChunkStore.queuedEdits` | covered |
 | `ChunkStore.revision` | covered |
 | `ChunkStore.seed` | covered |
 | `ChunkStore.setVoxel` | covered |

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/native/replication.hpp

@@ -738,6 +738,7 @@ class PyConnection {
     d["ring_dropped"] = s.ringDropped;
     d["reconnects"] = s.reconnects;
     d["idle_releases_after_input"] = s.idleReleasesAfterInput;
+    d["stale_bound_control"] = s.staleBoundControl;
     d["last_server_epoch_ms"] = s.lastServerEpochMs;
     nb::dict sentByType;
     nb::dict receivedByType;
@@ -797,6 +798,9 @@ class PyConnection {
     h.actorLeft = [this](const replication::SpatialNotification& n, std::uint8_t reason) {
       rows_.spatial(n, {reason, 0, 0, 0}, n.payload);
     };
+    h.chunkChanged = [this](const replication::SpatialNotification& n, std::int64_t updatedAtMs) {
+      rows_.spatial(n, {updatedAtMs, 0, 0, 0}, n.payload);
+    };
     auto event = [this](const replication::SpatialNotification& n, const wire::EventPayloadView& e) {
       rows_.spatial(n, {e.eventType, 0, 0, 0}, e.state);
     };

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/native/session_binding.cpp

@@ -51,6 +51,10 @@ struct SessionEvent {
     kDirectMessage,
     kEvent,
     kActorLeft,
+    /// An edit undone or not sent (CrowdyCPP 0.82.0): `chunk`; `a` the voxel (x, y, z as
+    /// 16-bit fields); `b` its type; `c` the result | restored << 8 | error code << 16;
+    /// `epochMs` the edit id.
+    kEditRefused,
   };
   int kind = 0;
   std::string lane;  // "" for the default lane
@@ -141,7 +145,8 @@ class PySession {
   PySession(PyConnection& conn, const std::string& appId, const std::string& actorUuid,
             int sendHz, std::int64_t keyframeIntervalMs, std::int64_t heartbeatIntervalMs,
             int distance, int decay, std::int64_t staleAfterMs, int historySize,
-            std::int64_t reapIntervalMs, int voxelSendDistance)
+            std::int64_t reapIntervalMs, int voxelSendDistance, int maxEditsInFlight,
+            int maxEditsPerSecond, std::int64_t editTimeoutMs)
       : conn_(conn) {
     session::WorldSessionConfig config;
     config.appId = appId;
@@ -155,6 +160,13 @@ class PySession {
     config.actors.historySize = historySize;
     config.chunks.writeBackIntervalMs = 0;  // durable write-back is the facade's
     config.chunks.voxelSendDistance = distance_arg(voxelSendDistance);
+    // The facade loads, re-reads and catches up itself; its staged source answers inline.
+    config.chunks.ioThread = false;
+    config.chunks.reloadReplacedChunks = false;
+    config.chunks.catchUpOnReconnect = false;
+    config.chunks.maxEditsInFlight = maxEditsInFlight;
+    config.chunks.maxEditsPerSecond = maxEditsPerSecond;
+    config.chunks.editTimeoutMs = editTimeoutMs;
     config.hostHeartbeatIntervalMs = 0;     // host election is the facade's
     config.reapIntervalMs = reapIntervalMs;
     auto forward = [this](const replication::SpatialNotification& n) {
@@ -178,6 +190,13 @@ class PySession {
       e.a = reason;
       events_.push_back(std::move(e));
     };
+    // The same row the connection's own handler gives, so `chunk_changed` reaches subscribers
+    // whether or not a session is attached.
+    config.onChunkChanged = [this, app = std::strtoll(appId.c_str(), nullptr, 10)](
+                                const wire::ChunkCoord& chunk, std::int64_t updatedAtMs) {
+      conn_.rowsLocked().push(static_cast<std::uint8_t>(wire::MessageType::ChunkChangedNotification),
+                              app, chunk, nullptr, 0, 0, {updatedAtMs, 0, 0, 0}, {});
+    };
     {
       std::lock_guard lock(conn_.consumerMutex());
       session::WorldSessionServices services;
@@ -187,6 +206,20 @@ class PySession {
     }
     conn_.attachSession(true);
     watchLane("");
+    session_->chunks().onEditRefused([this](const session::EditOutcome& o) {
+      SessionEvent e;
+      e.kind = SessionEvent::kEditRefused;
+      e.hasUuid = false;
+      e.chunk = o.coord;
+      e.a = (static_cast<std::int64_t>(static_cast<std::uint16_t>(o.x)) << 32) |
+            (static_cast<std::int64_t>(static_cast<std::uint16_t>(o.y)) << 16) |
+            static_cast<std::int64_t>(static_cast<std::uint16_t>(o.z));
+      e.b = o.voxelType;
+      e.c = static_cast<std::int64_t>(o.result) | (o.restored ? 1 << 8 : 0) |
+            (static_cast<std::int64_t>(o.errorCode) << 16);
+      e.epochMs = static_cast<std::int64_t>(o.editId);
+      events_.push_back(std::move(e));
+    });
     session_->chunks().onChunkChanged([this](const session::ChunkData& chunk) {
       if (!watchChunks_) return;
       SessionEvent e;
@@ -457,14 +490,15 @@ class PySession {
     const session::ChunkData* c = live().chunks().find(coord_of(x, y, z));
     if (!c) return std::nullopt;
     nb::dict states;
-    for (const auto& [index, state] : c->voxelStates)
+    c->forEachState([&](int index, const session::VoxelStateView& state) {
       states[nb::int_(index)] = nb::make_tuple(state.voxelType, blob(state.state));
+    });
     nb::list overlay;
-    for (const auto& [key, wide] : c->overlay)
-      overlay.append(
-          nb::make_tuple(wide.x, wide.y, wide.z, wide.voxel.voxelType, blob(wide.voxel.state)));
+    c->forEachOverlay([&](const session::OverlayVoxel& wide) {
+      overlay.append(nb::make_tuple(wide.x, wide.y, wide.z, wide.voxelType, blob(wide.state)));
+    });
     return nb::make_tuple(
-        nb::bytes(reinterpret_cast<const char*>(c->voxels.data()), c->voxels.size()), states,
+        nb::bytes(reinterpret_cast<const char*>(c->grid()), session::kChunkVolume), states,
         c->hydratedAtMs, overlay);
   }
 
@@ -512,25 +546,40 @@ class PySession {
   std::optional<nb::tuple> voxelStateAt(std::int64_t x, std::int64_t y, std::int64_t z, int vx,
                                         int vy, int vz) {
     std::lock_guard lock(conn_.consumerMutex());
-    const session::VoxelState* s = live().chunks().voxelStateAt(coord_of(x, y, z), vx, vy, vz);
+    const auto s = live().chunks().voxelStateAt(coord_of(x, y, z), vx, vy, vz);
     if (!s) return std::nullopt;
     return nb::make_tuple(s->voxelType, blob(s->state));
   }
 
-  int setVoxel(std::int64_t x, std::int64_t y, std::int64_t z, int vx, int vy, int vz,
-               int voxelType, nb::handle state, bool optimistic) {
+  /// Returns (edit id, the sequence number it went out with, or -1 while it waits its turn).
+  nb::tuple setVoxel(std::int64_t x, std::int64_t y, std::int64_t z, int vx, int vy, int vz,
+                     int voxelType, nb::handle state, bool optimistic) {
     BufferView body(state);
     const std::int16_t type = i16_arg(voxelType, "voxel type");
-    Result<std::uint8_t> result = Errc::InvalidArgument;
+    Result<std::uint64_t> result = Errc::InvalidArgument;
+    int sequence = -1;
     {
       nb::gil_scoped_release release;
       std::lock_guard lock(conn_.consumerMutex());
       auto& s = live();
       result = s.chunks().setVoxel(coord_of(x, y, z), vx, vy, vz, type, body.bytes(), s.actorUuid(),
                                    optimistic);
-      if (result.ok()) s.errors().recordSend(result.value(), session::SendKind::VoxelUpdate, s.actorUuid());
+      if (result.ok()) {
+        if (auto seq = s.chunks().sequenceOf(result.value())) sequence = *seq;
+      }
     }
-    return sent(result, "setVoxel");
+    if (!result.ok()) raise(result.error(), "setVoxel");
+    return nb::make_tuple(result.value(), sequence);
+  }
+
+  std::size_t editsInFlight() {
+    std::lock_guard lock(conn_.consumerMutex());
+    return live().chunks().editsInFlight();
+  }
+
+  std::size_t queuedEdits() {
+    std::lock_guard lock(conn_.consumerMutex());
+    return live().chunks().queuedEdits();
   }
 
   /// Insert a chunk the facade loaded from the durable store, or generated.
@@ -729,6 +778,7 @@ void register_session(nb::module_& m) {
   m.attr("DIRECT_MESSAGE") = static_cast<int>(SessionEvent::kDirectMessage);
   m.attr("EVENT") = static_cast<int>(SessionEvent::kEvent);
   m.attr("ACTOR_LEFT") = static_cast<int>(SessionEvent::kActorLeft);
+  m.attr("EDIT_REFUSED") = static_cast<int>(SessionEvent::kEditRefused);
   m.attr("MAX_STATE_BYTES") = session::kMaxStateBytes;
   m.attr("CHUNK_VOLUME") = session::kChunkVolume;
 
@@ -755,13 +805,15 @@ void register_session(nb::module_& m) {
 
   nb::class_<PySession>(m, "WorldSession")
       .def(nb::init<PyConnection&, const std::string&, const std::string&, int, std::int64_t,
-                    std::int64_t, int, int, std::int64_t, int, std::int64_t, int>(),
+                    std::int64_t, int, int, std::int64_t, int, std::int64_t, int, int, int,
+                    std::int64_t>(),
            nb::arg("connection"), nb::arg("app_id"), nb::arg("actor_uuid") = "",
            nb::arg("send_hz") = 5, nb::arg("keyframe_interval_ms") = 3000,
            nb::arg("heartbeat_interval_ms") = 2000, nb::arg("distance") = 8, nb::arg("decay") = 1,
            nb::arg("stale_after_ms") = 12000, nb::arg("history_size") = 2,
            nb::arg("reap_interval_ms") = 1000, nb::arg("voxel_send_distance") = 8,
-           nb::keep_alive<1, 2>())
+           nb::arg("max_edits_in_flight") = 128, nb::arg("max_edits_per_second") = 250,
+           nb::arg("edit_timeout_ms") = 10000, nb::keep_alive<1, 2>())
       .def("close", &PySession::close)
       .def("tick", &PySession::tick)
       .def("drain_events", &PySession::drainEvents)
@@ -808,6 +860,8 @@ void register_session(nb::module_& m) {
            nb::arg("distance"))
       .def("chunk_revision", &PySession::chunkRevision)
       .def("chunk_count", &PySession::chunkCount)
+      .def("edits_in_flight", &PySession::editsInFlight)
+      .def("queued_edits", &PySession::queuedEdits)
       .def("recent_errors", &PySession::recentErrors, nb::arg("limit") = SIZE_MAX)
       .def("error_total", &PySession::errorTotal)
       .def("clear_errors", &PySession::clearErrors)

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "crowdypy"
-version = "0.28.0.dev1"
+version = "0.30.0.dev1"
 description = "Official Python SDK for Crowded Kingdoms: typed GraphQL clients and a native UDP replication core"
 readme = "README.md"
 license = "MIT AND Apache-2.0"
@@ -119,19 +119,19 @@ environment = { OPENSSL_ROOT_DIR = "C:/vcpkg/installed/x64-windows-static-md" }
 # --------------------------------------------------------------------------------------
 
 [tool.crowdypy.crowdyjs]
-version = "18.28.0"
-commit = "bc8b2b0737c0caf1486358c721123fa72fc1b955"
+version = "18.30.0"
+commit = "4840d76029ffb15a6de6232dab9336f2e9ab6514"
 
 [tool.crowdypy.crowdycpp]
-version = "0.80.0"
-tag = "dev/v0.80.0"
-commit = "d0d95975d6a6bcf1e08c3fd1cbde4a8be433b062"
-tree-sha256 = "c59afbf19dbc517590ec3d98a018daae8d583125a6dcc135055e172c16b753d6"
+version = "0.82.0"
+tag = "dev/v0.82.0"
+commit = "c6875412bcea97120b4540b80d9b34504c29acf9"
+tree-sha256 = "44dca0b0bd34d575808e5bf7a1ca6944ce779a790b9187894761541623a0f3ec"
 
 # schema.gql and operations/ are CrowdyJS's, copied from the commit pinned above by
 # scripts/schema_sync.py, which records these hashes and re-derives them in CI.
 [tool.crowdypy.graphql]
-schema-sha256 = "77a5f321148142940ecc2f1d0b52a0b30d4e3d5918db5b19d1e978f688cd0c0c"
+schema-sha256 = "60a0a7a81bd90cb0b5decd62dc58736d037e61043a64f93b6f94a35311f0c7a1"
 operations-sha256 = "f2d61b107673668b345b29551c1979bbf93e34d5122c68cbd8a0d63ac59c25f9"
 
 # The SDL the docs site publishes. scripts/schema_drift.py compares the snapshot against it

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/schema.gql

@@ -14019,7 +14019,7 @@ type Subscription {
 """
 All game-server messages delivered over the UDP proxy as GraphQL payloads. Subscribe to udpNotifications before or with sending mutations so responses and GenericErrorResponse (correlate via sequenceNumber) are not missed. NOTE: the ActorUpdateResponse and VoxelUpdateResponse members are LEGACY and never emitted (applied updates arrive as your own *Notification self-echo; failures as GenericErrorResponse) — they remain in the union for backward compatibility and will be removed in a future major version.
 """
-union UdpNotification = ActorUpdateResponse | ActorUpdateNotification | VoxelUpdateResponse | VoxelUpdateNotification | ClientAudioNotification | ClientVideoNotification | ActorLeftNotification | ClientTextNotification | ClientEventNotification | ServerEventNotification | SingleActorMessageNotification | ChannelMessageNotification | ChannelAudioNotification | GenericErrorResponse | RealtimeConnectionEvent
+union UdpNotification = ActorUpdateResponse | ActorUpdateNotification | VoxelUpdateResponse | VoxelUpdateNotification | ClientAudioNotification | ClientVideoNotification | ActorLeftNotification | ChunkChangedNotification | ClientTextNotification | ClientEventNotification | ServerEventNotification | SingleActorMessageNotification | ChannelMessageNotification | ChannelAudioNotification | GenericErrorResponse | RealtimeConnectionEvent
 
 """
 LEGACY — never emitted. The game server retired the dedicated actor-update response opcode (129); an applied update now arrives as your own ActorUpdateNotification (the sender is included in the chunk fan-out) and failures arrive as GenericErrorResponse. This type remains in the UdpNotification union for backward compatibility only — do not select it in new code; it will be removed in a future major version.
@@ -14219,6 +14219,28 @@ type ActorLeftNotification {
   epochMillis: BigInt!
 }
 
+"""
+A chunk near you was replaced as a whole (a hub's or mod's world.set_chunk; Buddy v0.45.0): read it again with getChunk, or getChunksByDistance with since. It comes instead of a voxel update per voxel. Received via the udpNotifications subscription.
+"""
+type ChunkChangedNotification {
+  """The ID of the app the chunk is in."""
+  appId: BigInt!
+  """The X coordinate of the replaced chunk."""
+  chunkX: BigInt!
+  """The Y coordinate of the replaced chunk."""
+  chunkY: BigInt!
+  """The Z coordinate of the replaced chunk."""
+  chunkZ: BigInt!
+  """Chunk replication distance (0-8) the notification was fanned out over."""
+  distance: Int!
+  """
+  The stored chunk's new updatedAt, in epoch milliseconds: a copy at least this new is current.
+  """
+  updatedAtMs: BigInt!
+  """Correlation byte from the datagram tail (always 0 today)."""
+  sequenceNumber: Int!
+}
+
 """
 Notification received when another client sends a text message (chat). Received via the udpNotifications subscription.
 """

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/src/crowdypy/_generated/enums.py

@@ -1,6 +1,6 @@
 """GENERATED by scripts/codegen.py from schema.gql. Do not edit.
 
-schema.gql sha256: 77a5f321148142940ecc2f1d0b52a0b30d4e3d5918db5b19d1e978f688cd0c0c
+schema.gql sha256: 60a0a7a81bd90cb0b5decd62dc58736d037e61043a64f93b6f94a35311f0c7a1
 """
 
 from enum import StrEnum

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/src/crowdypy/_generated/inputs.py

@@ -4,7 +4,7 @@ Every GraphQL input object as a msgspec Struct. Attributes are snake_case and en
 under their GraphQL names; an attribute left at UNSET is omitted from the request,
 which is how the API tells 'not provided' from an explicit null.
 
-schema.gql sha256: 77a5f321148142940ecc2f1d0b52a0b30d4e3d5918db5b19d1e978f688cd0c0c
+schema.gql sha256: 60a0a7a81bd90cb0b5decd62dc58736d037e61043a64f93b6f94a35311f0c7a1
 """
 
 from __future__ import annotations

{crowdypy-0.28.0.dev1 → crowdypy-0.30.0.dev1}/src/crowdypy/_generated/operations.py

@@ -1,6 +1,6 @@
 """GENERATED by scripts/codegen.py from schema.gql and operations/. Do not edit.
 
-schema.gql sha256: 77a5f321148142940ecc2f1d0b52a0b30d4e3d5918db5b19d1e978f688cd0c0c
+schema.gql sha256: 60a0a7a81bd90cb0b5decd62dc58736d037e61043a64f93b6f94a35311f0c7a1
 operations/ sha256: f2d61b107673668b345b29551c1979bbf93e34d5122c68cbd8a0d63ac59c25f9
 """