crowdypy 0.5.1.dev1__tar.gz → 0.6.0.dev1__tar.gz

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/MIGRATION.md

@@ -3,6 +3,37 @@
 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.6.0
+
+CrowdyJS 18.5.0 and CrowdyCPP 0.58.0. Additive.
+
+- **Distance-limited channel messages.**
+  `client.udp.send_ranged_channel_message(channel_id, uuid, payload, *, chunk, max_distance)`
+  publishes to a channel but reaches only the members whose own actor is within
+  `max_distance` chunks of `chunk`. Distance is the straight line between chunk coordinates,
+  inclusive: 0 reaches only the origin chunk, and 5 reaches a member 3 chunks east and 4
+  north but not one 4 east and 4 north (about 5.66). It takes the same right as
+  `send_channel_message`, and members receive the ordinary `channel_message`, so receivers
+  change nothing. A member with no actor of its own is not reached, nor is the sender.
+  `max_distance` is 0 to `crowdypy.wire.CHANNEL_RANGED_MAX_DISTANCE` (2^31 - 1); the origin's
+  app is the connection's. Underneath it is
+  `ReplicationConnection.send_ranged_channel_message(channel_id, uuid, payload, chunk,
+  max_distance)`, and `crowdypy.wire.encode_ranged_channel_message` encodes the
+  CHANNEL_MESSAGE_RANGED_REQUEST (32) for a custom transport. It needs a replication server
+  that serves message type 32; one that does not delivers nothing.
+- **The terms and age gate** (CrowdyJS 18.4.0). Since ck-api v2.35.0 no gameplay token
+  (`portal.mint_app_token`, `portal.create_authorization_code`, `portal.refresh`) is issued
+  until the player has agreed to the current required legal documents and attested that they
+  are at least 18, or the age of majority where they live if higher; the refusal is
+  `LEGAL_ACCEPTANCE_REQUIRED`, which `crowdypy.is_legal_acceptance_required_error` reads.
+  Show your own two checkboxes, linking each document, then call
+  `client.auth.record_player_consents(accept_legal=True, attest_age_of_majority=True)` before
+  minting; `client.auth.player_legal_acceptance()` says whether that is still needed.
+  `client.auth.register` takes `accept_legal` and `attest_age_of_majority`, and an account
+  registered with both `True` starts accepted. Record them only for a player who ticked both
+  boxes: they are the player's agreement. Against an older API the two new calls fail as
+  GraphQL validation errors.
+
 ## 0.5.1
 
 CrowdyJS 18.2.0 and CrowdyCPP 0.56.0. No API change; one behaviour fix.

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crowdypy
-Version: 0.5.1.dev1
+Version: 0.6.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,10 +51,16 @@ 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.5.1: chunk loads keep recorded voxel edits (CrowdyJS 18.2.0, CrowdyCPP 0.56.0).**
-- `ChunkStore.hydrate()` puts every recorded voxel edit (`voxelStates`: a hub's or mod's
-  `world.set_voxels`, `updateVoxel`, realtime updates) on the grid, and a later
-  `ensure_around()` keeps a chunk it already loaded instead of reloading its bare voxels.
+**v0.6.0: distance-limited channel messages and the terms gate (CrowdyJS 18.5.0, CrowdyCPP 0.58.0).**
+- `client.udp.send_ranged_channel_message(..., chunk=, max_distance=)` publishes to a channel
+  but reaches only the members whose own actor is within `max_distance` chunks of `chunk`,
+  by straight-line distance. Members receive the ordinary `channel_message`.
+- `client.auth.record_player_consents()` and `player_legal_acceptance()`, `register`'s
+  `accept_legal` and `attest_age_of_majority`, and `is_legal_acceptance_required_error`: a
+  gameplay token now waits for the player's agreement to the legal documents and age
+  attestation.
+- 0.5.1 made `ChunkStore.hydrate()` keep every recorded voxel edit (`voxelStates`) and
+  `ensure_around()` keep a chunk it already loaded.
 - 0.5.0 brought the ck-exec gateway check (`client.exec.connect()` sends the connect token
   only to a gateway on the game API's estate, and reports a refusal as `Denied`) and open
   grids (`game_apps.open_permissions()` and `set_open_permissions()`).
@@ -136,7 +142,10 @@ There is one API origin but two tokens, as in every Crowded Kingdoms SDK:
    token**: account, studio administration and minting. It is not accepted for gameplay.
 2. Gameplay needs a short-lived **app-scoped token** per app
    (`portal.mint_app_token(app_id)`), which is also the HMAC key for native UDP. Refresh it
-   with `client.refresh_gameplay_token()` (concurrent callers share one refresh).
+   with `client.refresh_gameplay_token()` (concurrent callers share one refresh). It is
+   refused with `LEGAL_ACCEPTANCE_REQUIRED` until the player's agreement to the legal
+   documents and age attestation are stored: show both checkboxes, then call
+   `auth.record_player_consents(accept_legal=True, attest_age_of_majority=True)`.
 3. Build one identity client and one client per game. The game client points at the app's
    datacenter (`game_api_url`) with `discovery_url` set, so it can find the app again if
    that instance stops answering.

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/README.md

@@ -11,10 +11,16 @@ 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.5.1: chunk loads keep recorded voxel edits (CrowdyJS 18.2.0, CrowdyCPP 0.56.0).**
-- `ChunkStore.hydrate()` puts every recorded voxel edit (`voxelStates`: a hub's or mod's
-  `world.set_voxels`, `updateVoxel`, realtime updates) on the grid, and a later
-  `ensure_around()` keeps a chunk it already loaded instead of reloading its bare voxels.
+**v0.6.0: distance-limited channel messages and the terms gate (CrowdyJS 18.5.0, CrowdyCPP 0.58.0).**
+- `client.udp.send_ranged_channel_message(..., chunk=, max_distance=)` publishes to a channel
+  but reaches only the members whose own actor is within `max_distance` chunks of `chunk`,
+  by straight-line distance. Members receive the ordinary `channel_message`.
+- `client.auth.record_player_consents()` and `player_legal_acceptance()`, `register`'s
+  `accept_legal` and `attest_age_of_majority`, and `is_legal_acceptance_required_error`: a
+  gameplay token now waits for the player's agreement to the legal documents and age
+  attestation.
+- 0.5.1 made `ChunkStore.hydrate()` keep every recorded voxel edit (`voxelStates`) and
+  `ensure_around()` keep a chunk it already loaded.
 - 0.5.0 brought the ck-exec gateway check (`client.exec.connect()` sends the connect token
   only to a gateway on the game API's estate, and reports a refusal as `Denied`) and open
   grids (`game_apps.open_permissions()` and `set_open_permissions()`).
@@ -96,7 +102,10 @@ There is one API origin but two tokens, as in every Crowded Kingdoms SDK:
    token**: account, studio administration and minting. It is not accepted for gameplay.
 2. Gameplay needs a short-lived **app-scoped token** per app
    (`portal.mint_app_token(app_id)`), which is also the HMAC key for native UDP. Refresh it
-   with `client.refresh_gameplay_token()` (concurrent callers share one refresh).
+   with `client.refresh_gameplay_token()` (concurrent callers share one refresh). It is
+   refused with `LEGAL_ACCEPTANCE_REQUIRED` until the player's agreement to the legal
+   documents and age attestation are stored: show both checkboxes, then call
+   `auth.record_player_consents(accept_legal=True, attest_age_of_majority=True)`.
 3. Build one identity client and one client per game. The game client points at the app's
    datacenter (`game_api_url`) with `discovery_url` set, so it can find the app again if
    that instance stops answering.

{crowdypy-0.5.1.dev1 → crowdypy-0.6.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.5.1`
+- CrowdyPy `0.6.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
@@ -38,3 +38,8 @@ requirement names one exactly, the same way a caret never matches an npm prerele
   `exec*` roots answers those calls with a GraphQL validation error.
 - Direct sign-in (`auth.login`, `auth.register`) is served to non-browser callers. CrowdyPy
   sends no `Origin` header, so it is exempt from `HOSTED_SIGN_IN_REQUIRED`.
+- `auth.record_player_consents` and `auth.player_legal_acceptance` need ck-api v2.35.0; an
+  older API answers them with a GraphQL validation error. From v2.35.0 a gameplay token
+  waits for both consents (`LEGAL_ACCEPTANCE_REQUIRED`).
+- `udp.send_ranged_channel_message` needs a replication server that serves message type 32
+  (CHANNEL_MESSAGE_RANGED_REQUEST); one that does not delivers nothing.

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/docs/e2e-coverage.md

@@ -36,10 +36,11 @@ player once and signs it in for the later suites.
 
 | Suite | Scenarios | CrowdyCPP counterpart |
 |---|---|---|
-| `test_e2e_identity.py` | register and sign in; mint an app token (64 octets) and refresh it; `serverWithLeastClients` with the app token; a wrong password is refused; the identity session token is refused for gameplay | `e2e_auth_identities`, `e2e_negative_auth`, `e2e_gameplay_token_refresh` |
+| `test_e2e_identity.py` | register and sign in; mint an app token (64 octets) and refresh it; `serverWithLeastClients` with the app token; a player registered without the legal consents is refused a gameplay token (`LEGAL_ACCEPTANCE_REQUIRED`) until `record_player_consents`, and `player_legal_acceptance` follows; a wrong password is refused; the identity session token is refused for gameplay | `e2e_auth_identities`, `e2e_negative_auth`, `e2e_gameplay_token_refresh` |
 | `test_e2e_replication.py` | two players over native UDP: an actor update reaches the other player and echoes back to the sender; a 16-entity batched frame (`send_actor_updates`) reaches the other player; voxel updates and client events reach the other player | `e2e_two_client_actor`, `e2e_self_echo`, `e2e_spatial_distance` |
 | `test_e2e_world.py` | two World Stores sessions: each sees the other's actor natively; a voxel edit lands in the other session's chunk store | `e2e_stores_live`, `e2e_world_session` |
 | `test_e2e_world_data.py` | a GraphQL voxel write by an entitled player is recorded and listed back | `e2e_chunks` |
+| `test_e2e_ranged_channel.py` | the owner's invite channel with four members, each keeping an actor at its own chunk: a distance-limited channel message from A reaches B at 5 chunks with `max_distance` 5 but not C (about 5.66) or D (7); 6 adds C, 7 adds D; A never receives its own; no send is refused | `e2e_ranged_channel` |
 | `test_e2e_open_grid_exec_gateway.py` | as a throwaway org admin (`CROWDY_E2E_THROWAWAY_OWNER=1`): open a nested grid, read it back, a player holds its keys, a player-code key is refused `BAD_REQUEST`, close it; the tier's ck-exec gateway passes `exec_gateway_refusal`, a connection pings, and a tampered connect token is `Denied` with the gateway's HTTP 401 reason | `e2e_open_grid_exec_gateway` |
 | `test_e2e_studio.py` | the headless Studio controller creates a project from the mod starter, edits it with autosave, and archives it (optional: needs `CROWDY_E2E_STUDIO_GRID_ID`) | `e2e_crowdy_studio` |
 
@@ -52,6 +53,7 @@ player once and signs it in for the later suites.
 | 2026-10-01 | dev tier, app `96701660793088` | the published `dev/v0.4.0` wheel (`0.4.0.dev1`, manylinux x86_64, installed into a clean Python 3.12) | 8 passed |
 | 2026-10-01 | dev tier, app `96701660793088` | `crowdypy 0.4.1.dev1` from PyPI (`pip install crowdypy` in a clean Python 3.12; the first version published by trusted publishing) | 8 passed; Studio skipped |
 | 2026-10-01 | dev tier, app `96701660793088`; the open-grid suite in its own throwaway org and app (`CROWDY_E2E_THROWAWAY_OWNER=1`) | `crowdypy 0.5.0.dev1` from PyPI (`pip install crowdypy` in a clean Python 3.12) | 10 passed; Studio skipped |
+| 2026-10-08 | local stack: ck-api at the distance-limited channel branch (off `dev`), two replication servers serving message type 32, the 3-node Citus lab | 0.6.0 (branch) | identity, ranged channel, replication, world and world data suites: 10 passed |
 
 ## Not covered here
 

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/docs/parity-matrix.md

@@ -4,16 +4,16 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 
 ## Target
 
-- CrowdyJS: `18.2.0` at `269966d158f45749e9a563abf6032369ae0c258a`
-- CrowdyCPP (native core): `0.56.0` at `910ce23082940b570dc02f009d68d31594bd4be3`
+- CrowdyJS: `18.5.0` at `ae249cbe5661c5d14394994f66083d2731fab7e0`
+- CrowdyCPP (native core): `0.58.0` at `cae2f4af8a7af79cec12b612213b738c41969b1d`
 - schema.gql identical to CrowdyJS's: yes
 - Gate mode: strict portable parity (every portable gap is release-blocking)
 
 ## Summary
 
-- Covered: 1012
+- Covered: 1019
 - Portable gap: 0
-- Native equivalent: 38
+- Native equivalent: 40
 - Browser exclusion: 95
 - Deprecated roots: 2
 - Unclassified: 0
@@ -137,6 +137,7 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `mutation.mintAppToken` | covered |
 | `mutation.mintGridToken` | covered |
 | `mutation.publishAppToShared` | covered |
+| `mutation.recordPlayerConsents` | covered |
 | `mutation.refreshAppToken` | covered |
 | `mutation.register` | covered |
 | `mutation.reinstateOrganization` | browser exclusion — operator-only organization lifecycle; not a game-client surface |
@@ -164,6 +165,7 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `mutation.sendAudioPacket` | native equivalent — client.udp sends and receives this over CrowdyCPP's native UDP connection; the GraphQL UDP proxy exists because a page cannot open a UDP socket |
 | `mutation.sendChannelMessage` | native equivalent — client.udp sends and receives this over CrowdyCPP's native UDP connection; the GraphQL UDP proxy exists because a page cannot open a UDP socket |
 | `mutation.sendClientEvent` | native equivalent — client.udp sends and receives this over CrowdyCPP's native UDP connection; the GraphQL UDP proxy exists because a page cannot open a UDP socket |
+| `mutation.sendRangedChannelMessage` | native equivalent — client.udp sends and receives this over CrowdyCPP's native UDP connection; the GraphQL UDP proxy exists because a page cannot open a UDP socket |
 | `mutation.sendSingleActorMessage` | native equivalent — client.udp sends and receives this over CrowdyCPP's native UDP connection; the GraphQL UDP proxy exists because a page cannot open a UDP socket |
 | `mutation.sendTestEmail` | browser exclusion — operator-only email deliverability control; not a game-client surface |
 | `mutation.sendTextPacket` | native equivalent — client.udp sends and receives this over CrowdyCPP's native UDP connection; the GraphQL UDP proxy exists because a page cannot open a UDP socket |
@@ -376,6 +378,7 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `query.placeableDatacenters` | covered |
 | `query.platformConfig` | covered |
 | `query.playerAutoBilling` | covered |
+| `query.playerLegalAcceptance` | covered |
 | `query.playerPulse` | covered |
 | `query.playerRateMarkup` | covered |
 | `query.playerRuntimeStates` | covered |
@@ -546,6 +549,8 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `AuthAPI.logout` | covered |
 | `AuthAPI.logoutAllDevices` | covered |
 | `AuthAPI.myIdentities` | covered |
+| `AuthAPI.playerLegalAcceptance` | covered |
+| `AuthAPI.recordPlayerConsents` | covered |
 | `AuthAPI.register` | covered |
 | `AuthAPI.requestLoginLink` | covered |
 | `AuthAPI.requestPasswordReset` | covered |
@@ -1000,6 +1005,7 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `UdpAPI.sendChannelMessage` | covered |
 | `UdpAPI.sendClientEvent` | covered |
 | `UdpAPI.sendClientEventAndWait` | covered |
+| `UdpAPI.sendRangedChannelMessage` | covered |
 | `UdpAPI.sendSingleActorMessage` | covered |
 | `UdpAPI.sendTextPacket` | covered |
 | `UdpAPI.sendTextPacketAndWait` | covered |
@@ -1042,6 +1048,7 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `BUNDLE_LENGTH_PREFIX_BYTES` | native equivalent — the same codec, CrowdyCPP's, through crowdypy.wire: crowdypy.wire.bundle() / split_datagram(), which own the bundle layout |
 | `BinaryRelayTransport` | browser exclusion — the raw-WebSocket relay exists because a page cannot open a UDP socket; CrowdyPy replicates over native UDP (CrowdyCPP's core) |
 | `BrowserLocalStorageTokenStore` | native equivalent — token persistence is TokenStore / SessionStore; the localStorage backing is browser-only, and FileTokenStore mirrors its session / app key split |
+| `CHANNEL_RANGED_MAX_DISTANCE` | covered |
 | `CLIENT_GRID_EVENT_MAX_CASCADE` | browser exclusion — page-local event bus between CLIENT mods running in this browser's glue workers |
 | `CROWDY_DEFAULT_HOST` | covered |
 | `CROWDY_DEFAULT_HTTP_ORIGIN` | covered |
@@ -1142,6 +1149,7 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `isAlreadyRegisteredError` | covered |
 | `isHostedSignInRequiredError` | covered |
 | `isInvalidCurrentPasswordError` | covered |
+| `isLegalAcceptanceRequiredError` | covered |
 | `isNewerFrameId` | covered |
 | `isNoPasswordSetError` | covered |
 | `isPasswordAlreadySetError` | covered |
@@ -1172,6 +1180,7 @@ Generated by `tools/parity/parity.py`; do not edit by hand. Classifications live
 | `serializeAudioPacket` | native equivalent — the same codec, CrowdyCPP's, through crowdypy.wire: crowdypy.wire.encode_long_spatial with the message type |
 | `serializeChannelMessage` | native equivalent — the same codec, CrowdyCPP's, through crowdypy.wire: crowdypy.wire.encode_channel_message with the message type |
 | `serializeClientEvent` | native equivalent — the same codec, CrowdyCPP's, through crowdypy.wire: crowdypy.wire.encode_long_spatial with the message type |
+| `serializeRangedChannelMessage` | native equivalent — the same codec, CrowdyCPP's, through crowdypy.wire: crowdypy.wire.encode_ranged_channel_message |
 | `serializeSingleActorMessage` | native equivalent — the same codec, CrowdyCPP's, through crowdypy.wire: crowdypy.wire.encode_long_spatial with the message type |
 | `serializeTextPacket` | native equivalent — the same codec, CrowdyCPP's, through crowdypy.wire: crowdypy.wire.encode_long_spatial with the message type |
 | `serializeVideoPacket` | native equivalent — the same codec, CrowdyCPP's, through crowdypy.wire: crowdypy.wire.encode_long_spatial with the message type |

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/native/replication.hpp

@@ -552,6 +552,19 @@ class PyConnection {
     return sent(result, "sendChannelMessage");
   }
 
+  int sendRangedChannel(std::int64_t channelId, nb::handle uuid, nb::handle payload, std::int64_t x,
+                        std::int64_t y, std::int64_t z, std::uint32_t maxDistance) {
+    const core::ActorUuid id = uuid_from(uuid);
+    BufferView body(payload);
+    Result<std::uint8_t> result = Errc::InvalidArgument;
+    {
+      nb::gil_scoped_release release;
+      result = connection_->sendRangedChannelMessage(channelId, id, body.bytes(), {x, y, z},
+                                                     maxDistance);
+    }
+    return sent(result, "sendRangedChannelMessage");
+  }
+
   int sendHeartbeat(std::int64_t x, std::int64_t y, std::int64_t z, nb::handle uuid) {
     const core::ActorUuid id = uuid_from(uuid);
     Result<std::uint8_t> result = Errc::InvalidArgument;

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/native/replication_binding.cpp

@@ -280,6 +280,9 @@ void register_replication(nb::module_& m) {
            nb::arg("z"), nb::arg("uuid"), nb::arg("payload"))
       .def("send_channel_message", &PyConnection::sendChannel, nb::arg("channel_id"),
            nb::arg("uuid"), nb::arg("payload"))
+      .def("send_ranged_channel_message", &PyConnection::sendRangedChannel, nb::arg("channel_id"),
+           nb::arg("uuid"), nb::arg("payload"), nb::arg("x"), nb::arg("y"), nb::arg("z"),
+           nb::arg("max_distance"))
       .def("send_heartbeat", &PyConnection::sendHeartbeat, nb::arg("x"), nb::arg("y"), nb::arg("z"),
            nb::arg("uuid"))
       .def("send_video_frame", &PyConnection::sendVideoFrame, nb::arg("x"), nb::arg("y"),

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/native/wire_binding.cpp

@@ -99,6 +99,29 @@ nb::bytes encode_channel_message(nb::handle token_obj, std::int64_t channel_id,
   return to_bytes(Bytes(buf, n.value()));
 }
 
+nb::bytes encode_ranged_channel_message(nb::handle token_obj, std::int64_t channel_id,
+                                        nb::handle uuid_obj, nb::handle payload_obj,
+                                        std::int64_t app_id, std::int64_t chunk_x,
+                                        std::int64_t chunk_y, std::int64_t chunk_z,
+                                        std::uint32_t max_distance, std::int64_t game_token_id,
+                                        std::uint8_t sequence) {
+  const auto token = token_from(token_obj);
+  BufferView payload(payload_obj);
+  wire::RangedChannelMessageParams p;
+  p.channelId = channel_id;
+  p.uuid = uuid_from(uuid_obj);
+  p.appId = app_id;
+  p.origin = {chunk_x, chunk_y, chunk_z};
+  p.maxDistance = max_distance;
+  p.payload = payload.bytes();
+  p.gameTokenId = game_token_id;
+  p.sequence = sequence;
+  std::uint8_t buf[wire::kMaxDatagramSize];
+  auto n = wire::encodeRangedChannelMessage(crypto(), p, token, MutableBytes(buf, sizeof(buf)));
+  if (!n.ok()) raise(n.error(), "cannot encode this ranged channel message");
+  return to_bytes(Bytes(buf, n.value()));
+}
+
 nb::tuple parse_channel_notification(nb::handle datagram_obj) {
   BufferView datagram(datagram_obj);
   auto v = wire::parseChannelNotification(datagram.bytes());
@@ -173,6 +196,7 @@ void register_wire(nb::module_& m) {
   m.attr("MAX_BUNDLE_MEMBERS") = wire::kMaxBundleMembers;
   m.attr("MAX_BUNDLE_MEMBER_SIZE") = wire::kMaxBundleMemberSize;
   m.attr("MAX_CHANNEL_PAYLOAD") = wire::channel::kMaxPayload;
+  m.attr("CHANNEL_RANGED_MAX_DISTANCE") = wire::channel_ranged::kMaxDistance;
   m.attr("MAX_DISTANCE") = wire::kMaxDistance;
   m.attr("CLIENT_CAPABILITIES_ALL") = wire::ClientCapability::kAll;
 
@@ -189,6 +213,10 @@ void register_wire(nb::module_& m) {
   m.def("encode_channel_message", &encode_channel_message, nb::arg("token"),
         nb::arg("channel_id"), nb::arg("uuid"), nb::arg("payload"), nb::arg("game_token_id"),
         nb::arg("sequence"));
+  m.def("encode_ranged_channel_message", &encode_ranged_channel_message, nb::arg("token"),
+        nb::arg("channel_id"), nb::arg("uuid"), nb::arg("payload"), nb::arg("app_id"),
+        nb::arg("chunk_x"), nb::arg("chunk_y"), nb::arg("chunk_z"), nb::arg("max_distance"),
+        nb::arg("game_token_id"), nb::arg("sequence"));
   m.def("parse_channel_notification", &parse_channel_notification, nb::arg("datagram"));
   m.def("parse_generic_error", &parse_generic_error, nb::arg("datagram"));
   m.def("encode_voxel_payload", &encode_voxel_payload, nb::arg("x"), nb::arg("y"),

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "crowdypy"
-version = "0.5.1.dev1"
+version = "0.6.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"
@@ -117,19 +117,19 @@ environment = { OPENSSL_ROOT_DIR = "C:/vcpkg/installed/x64-windows-static-md" }
 # --------------------------------------------------------------------------------------
 
 [tool.crowdypy.crowdyjs]
-version = "18.2.0"
-commit = "269966d158f45749e9a563abf6032369ae0c258a"
+version = "18.5.0"
+commit = "ae249cbe5661c5d14394994f66083d2731fab7e0"
 
 [tool.crowdypy.crowdycpp]
-version = "0.56.0"
-tag = "910ce23082940b570dc02f009d68d31594bd4be3"
-commit = "910ce23082940b570dc02f009d68d31594bd4be3"
-tree-sha256 = "1e294223900a84c064ba8c50281edfe5cea2c7c2ac042d842fa5a7804ad89cd4"
+version = "0.58.0"
+tag = "dev/v0.58.0"
+commit = "cae2f4af8a7af79cec12b612213b738c41969b1d"
+tree-sha256 = "18db491aa66a14e209437b296d1bdd002746ebb811c5f39309a93b7bbb9d98d2"
 
 # 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 = "f00952f685420f6c0f4bf58d56debda29aea8cce9b877754393611393ff63db1"
+schema-sha256 = "29d59267d8bf5a0497b272ac22b5edfb702c4872087b0cffaa1542a81c917834"
 operations-sha256 = "d5e0c505589ea26ecc3398b12f02ad7bd786457f7010ad87dcb8af2ea9366c77"
 
 # The SDL the docs site publishes. scripts/schema_drift.py compares the snapshot against it

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/schema.gql

@@ -2057,6 +2057,20 @@ type PaymentMethodSetup {
   publishableKey: String
 }
 
+"""
+One band of a graduated price. Each unit of the period's running total is priced at the band its position falls in, so the price of the next unit never rises as the total grows. Bands are edges on the whole total and count from zero: the free allowance fills the first band first.
+"""
+type RateCardBandType {
+  """
+  Exclusive upper edge of this band on the period's running total, in raw metric units, as a BigInt decimal string. A band covers units from the previous band's edge up to this one. Null on the last band, which has no upper edge.
+  """
+  upToUnits: BigInt
+  """
+  Cents charged per the row's unitQuantity raw units for the units inside this band. Fractional values are permitted.
+  """
+  priceCents: Float!
+}
+
 """
 One priced dimension: its rate and, where it has one, its hourly free allowance. A dimension with a price of 0 is metered but not charged.
 """
@@ -2099,6 +2113,10 @@ type RateCardEntryType {
   freePeriod: AllowancePeriod
   """Operator note on the seed row; null when unset."""
   description: String
+  """
+  The graduated price, band by band, or null when the dimension has one flat price. When present the bands price the period total and priceCents is the first band's price. aggregate_data_volume (egress) is the dimension priced this way.
+  """
+  priceBands: [RateCardBandType!]
 }
 
 """
@@ -2184,6 +2202,10 @@ type PublicRateCardEntryType {
   The period freeUnits resets on. Every dimension is billed as its period aggregate crosses each whole cent, within about a minute of the usage arriving.
   """
   freePeriod: AllowancePeriod
+  """
+  The graduated price, band by band, or null when the dimension has one flat price. Egress (aggregate_data_volume) is priced this way per app per calendar month: each GB is charged at the band the app's month-to-date total has reached, and priceCents is the first band's price.
+  """
+  priceBands: [RateCardBandType!]
 }
 
 """
@@ -2193,11 +2215,11 @@ type RateChangeType {
   scope: RateScope!
   metric: String!
   """
-  One of "priceCents", "unitLabel", "unitQuantity", "freeUnits", "freePeriod" or "freePerMonth".
+  One of "priceCents", "priceBands", "unitLabel", "unitQuantity", "freeUnits", "freePeriod" or "freePerMonth".
   """
   field: String!
   """
-  The value before this call, as a decimal string. "none" when there was no allowance row.
+  The value before this call, as a decimal string; for priceBands the schedule as JSON. "none" when there was no allowance row, or no bands.
   """
   previous: String!
   """The value after this call, as a decimal string."""
@@ -6241,6 +6263,10 @@ type Query {
     tierId: BigInt
   ): [GmTierFeature!]! @requiresPermission(scope: "app", permission: "manage_apps", scopeArg: "appId")
   """
+  Whether the signed-in account has stored the current required legal documents and the age-of-majority attestation. False means createPortalAuthorizationCode and mintAppToken will refuse with LEGAL_ACCEPTANCE_REQUIRED until recordPlayerConsents. Requires a session token.
+  """
+  playerLegalAcceptance: Boolean!
+  """
   The federated sign-in providers currently enabled (e.g. ['google']). Use one with socialLoginStart.
   """
   availableLoginProviders: [String!]!
@@ -7972,6 +7998,17 @@ type Mutation {
     input: GrantTierFeatureInput!
   ): Boolean! @requiresPermission(scope: "app", permission: "manage_apps", scopeArg: "input.appId")
   """
+  Store acceptance of the current required legal documents (Game Terms, API Terms, SDK Developer Terms, Free Tier and Billing Basis, Overworld Privacy Policy) and the age-of-majority attestation. Both arguments must be true; a false value stores nothing and is refused with LEGAL_ACCEPTANCE_REQUIRED. Idempotent for a version already stored. Requires a session token. Gameplay tokens stay refused until this has succeeded for the current document set.
+  """
+  recordPlayerConsents(
+    """True when the player agrees to the current required legal documents."""
+    acceptLegal: Boolean!
+    """
+    True when the player attests they are at least 18, or the age of majority where they live if that is higher.
+    """
+    attestAgeOfMajority: Boolean!
+  ): Boolean!
+  """
   Passwordless: email a one-time magic sign-in link to the address (creates the account on first sign-in). Always reports sent=true (no account enumeration). Public; first-party origins only (HOSTED_SIGN_IN_REQUIRED otherwise); rate-limited.
   """
   requestLoginLink(input: RequestLoginLinkInput!): RequestLoginLinkResult!
@@ -7997,7 +8034,7 @@ type Mutation {
     loginUserInput: LoginUserInput!
   ): AuthResponse!
   """
-  Registers a new email + password account: creates the (initially unconfirmed) account, emails a confirmation link, and returns an AuthResponse with a session `token` for immediate use (send as `Authorization: Bearer <token>`). If an account already exists for the email it is refused with extensions.code EMAIL_ALREADY_REGISTERED (409) and no session is returned: an account that already has a password is left exactly as it was (sign in, or use the emailed reset), and only a password-less account (created via magic link/social) gets the password attached pending email confirmation. It is a routine outcome rather than a fault, and it reached clients as INTERNAL_SERVER_ERROR before v1.60.0, which is why several of them match it by its message text. Public; first-party origins only (HOSTED_SIGN_IN_REQUIRED otherwise); rate-limited.
+  Registers a new email + password account: creates the (initially unconfirmed) account, emails a confirmation link, and returns an AuthResponse with a session `token` for immediate use (send as `Authorization: Bearer <token>`). If an account already exists for the email it is refused with extensions.code EMAIL_ALREADY_REGISTERED (409) and no session is returned: an account that already has a password is left exactly as it was (sign in, or use the emailed reset), and only a password-less account (created via magic link/social) gets the password attached pending email confirmation. It is a routine outcome rather than a fault, and it reached clients as INTERNAL_SERVER_ERROR before v1.60.0, which is why several of them match it by its message text. A browser request (Origin header present) must send acceptLegal and attestAgeOfMajority both true or it is refused with LEGAL_ACCEPTANCE_REQUIRED before an account is created; a request with no Origin may omit them, and gameplay tokens stay refused until the documents are stored. Public; first-party origins only (HOSTED_SIGN_IN_REQUIRED otherwise); rate-limited.
   """
   register(
     """
@@ -8376,7 +8413,7 @@ type Mutation {
   """
   runSharedUsageBillingTick: Boolean! @requiresPermission(scope: "operator", permission: "is_operator")
   """
-  OPERATOR ONLY. Sets a metered dimension's price, the UNIT that price is quoted in, its free allowances, or any combination, and returns the new row alongside the values that moved. THIS IS THE ONLY SANCTIONED WAY TO CHANGE A PRICE OR A UNIT: the schema seeds use ON CONFLICT DO NOTHING, so a rate reaches a tier once at install and a unit corrected in the declaration never reaches a tier that already exists. Refuses an unknown or unmetered metric (a rate for a dimension nothing meters bills nobody while appearing configured), refuses a negative price, refuses unitLabel without unitQuantity (which would restate the rate card while the arithmetic kept the old divisor), and refuses a call that would change nothing. A unit change that also moves the money needs acknowledgeRepricing: true, so restating a price and cutting it cannot be confused. NOT RETROACTIVE: charges already written are history and the tick is idempotent per closed hour, so a new rate applies to hours billed from now on. Takes effect within about a minute — both billing ticks reload the card on every run, so no restart is needed.
+  OPERATOR ONLY. Sets a metered dimension's price, the UNIT that price is quoted in, its free allowances, or any combination, and returns the new row alongside the values that moved. THIS IS THE ONLY SANCTIONED WAY TO CHANGE A PRICE OR A UNIT: the schema seeds use ON CONFLICT DO NOTHING, so a rate reaches a tier once at install and a unit corrected in the declaration never reaches a tier that already exists. Refuses an unknown or unmetered metric (a rate for a dimension nothing meters bills nobody while appearing configured), refuses a negative price, refuses unitLabel without unitQuantity (which would restate the rate card while the arithmetic kept the old divisor), and refuses a call that would change nothing. A unit change that also moves the money needs acknowledgeRepricing: true, so restating a price and cutting it cannot be confused. priceBands sets a graduated schedule (SHARED aggregate_data_volume only; band 1 becomes priceCents) and clearPriceBands returns the dimension to one flat price; while a dimension is banded a bare priceCents or a unit change is refused. NOT RETROACTIVE: charges already written are history and the tick is idempotent per closed hour, so a new rate applies to hours billed from now on. Takes effect within about a minute — both billing ticks reload the card on every run, so no restart is needed.
   """
   setBillingRate(
     """Which dimension to reprice, the new price and/or allowance, and why."""
@@ -9504,6 +9541,15 @@ type Mutation {
     """
     input: ChannelMessageInput!
   ): Boolean!
+  """
+  Publish a message to a channel that only reaches members near an origin chunk: a member receives it, as an ordinary ChannelMessageNotification on udpNotifications, when one of its live actors is in the same app within maxDistance chunks of input.chunk (straight-line distance between chunk coordinates, boundary included). A member with no live actor does not receive it. Requires a bearer game token and the channel send_messages permission, as for sendChannelMessage; the origin app must be the token’s app. Opens a UDP proxy session automatically if none exists. The sender receives no echo. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING — NOT confirmation of delivery; failures arrive ASYNCHRONOUSLY as GenericErrorResponse on udpNotifications (UNAUTHORIZED without the send right, INVALID_APP_ID for another app), correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays).
+  """
+  sendRangedChannelMessage(
+    """
+    The channel message to publish: channelId (groups.group_id), the sender’s 32-byte actor uuid, base64 payload (max 1024 bytes), the origin appId and chunk, maxDistance in chunks, and optional sequenceNumber. See RangedChannelMessageInput.
+    """
+    input: RangedChannelMessageInput!
+  ): Boolean!
 }
 
 input UpdateGamertagInput {
@@ -9812,6 +9858,14 @@ input RegisterUserInput {
   Optional initial public gamertag (min 3 characters). Can be set later via updateGamertag.
   """
   gamertag: String
+  """
+  True when the player has agreed to the current required legal documents (Game Terms, API Terms, SDK Developer Terms, Free Tier and Billing Basis, Overworld Privacy Policy). A browser signup that omits this, or sends false, is refused with LEGAL_ACCEPTANCE_REQUIRED. Calls with no Origin header may omit it; gameplay tokens stay refused until the documents are stored.
+  """
+  acceptLegal: Boolean
+  """
+  True when the player attests they are at least 18, or the age of majority where they live if that is higher. Same requirement as acceptLegal: required on a browser signup, optional when the request has no Origin.
+  """
+  attestAgeOfMajority: Boolean
 }
 
 input ResetPasswordInput {
@@ -10147,11 +10201,30 @@ input SetRateCardInput {
   """
   freePerMonth: BigInt
   """
+  A whole graduated schedule, replacing the one the dimension holds: 1 to 10 bands, ascending edges, the last band open, no band dearer than the one below. Band 1's price becomes priceCents (supply priceCents only if it is the same). Accepted for SHARED aggregate_data_volume only. Like every price, it applies from a dimension's next period where a period has already been charged.
+  """
+  priceBands: [RateCardBandInput!]
+  """
+  true removes the dimension's bands so it is priced flat at priceCents (the former first band's price unless priceCents is also given). Not combinable with priceBands.
+  """
+  clearPriceBands: Boolean
+  """
   Why this price is changing. Required: a rate change with no stated reason is not auditable after the fact. Recorded in the operator log with the before and after values.
   """
   reason: String!
 }
 
+input RateCardBandInput {
+  """
+  Exclusive upper edge of this band on the period's running total, in raw metric units, as a BigInt decimal string. Every band but the last needs one, strictly above the band before; the last band must leave it null.
+  """
+  upToUnits: BigInt
+  """
+  Cents per the row's unitQuantity raw units inside this band: >= 0, at most six decimals, and never more than the band below it.
+  """
+  priceCents: Float!
+}
+
 """
 Set or change an app's reserved REALTIME (UDP) capacity on the shared environment. Reservations are sold in two independent dimensions and this mutation sets one of them; read both back from App.reservedUdpBytesPerSec and App.reservedGraphqlOpsPerSec.
 """
@@ -11611,6 +11684,38 @@ input ChannelMessageInput {
   sequenceNumber: Int
 }
 
+"""
+Input for publishing a channel message that only reaches members near an origin chunk. A member receives it when one of its live actors is in the same app within maxDistance chunks of the origin, measured as the straight-line (Euclidean) distance between chunk coordinates, boundary included; a member with no live actor does not receive it. Members receive an ordinary ChannelMessageNotification. The sender must have the channel send_messages permission, exactly as for sendChannelMessage.
+"""
+input RangedChannelMessageInput {
+  """The channel id (groups.group_id) to publish to."""
+  channelId: BigInt!
+  """
+  The sender's actor UUID (your own actor's UUID). Must be exactly 32 bytes when encoded as UTF-8.
+  """
+  uuid: String!
+  """
+  The message payload, base64-encoded. Opaque to the server; decode per your application protocol. Max 1024 bytes.
+  """
+  payload: String!
+  """
+  The app the origin chunk is in. Must be the app this token is scoped to (the game server answers INVALID_APP_ID otherwise).
+  """
+  appId: BigInt!
+  """
+  The origin chunk distance is measured from, usually the chunk of the sending actor. A chunk is a 16x16x16 voxel cube.
+  """
+  chunk: ChunkCoordinatesInput!
+  """
+  Largest straight-line distance from the origin chunk, in chunks, at which a member still receives the message: 0 (the origin chunk only) to 2147483647. Not capped at 8 and not the Chebyshev ring count spatial sends use.
+  """
+  maxDistance: Int!
+  """
+  Client-assigned correlation id for this datagram: a uint8 (0-255) that wraps at gameClientBootstrap.sequenceNumberModulo (256); defaults to 0 if omitted. For CORRELATION ONLY — it is NOT an idempotency key and the server does not dedupe replays. Echoed on any GenericErrorResponse for this send, delivered on the udpNotifications subscription.
+  """
+  sequenceNumber: Int
+}
+
 type Subscription {
   """
   Realtime downlink from the game server: spatial notifications and responses, GenericErrorResponse (errors from your sends, correlated by sequenceNumber), and RealtimeConnectionEvent (lifecycle/setup failures). Requires a bearer game token AND an appId-scoped connection — the appId is read from the graphql-transport-ws connection (game tokens are app-agnostic and one UDP socket is shared across apps, so an app-agnostic subscription is rejected with a RealtimeConnectionEvent code APP_ID_REQUIRED, and a missing/invalid token with AUTH_REQUIRED). On subscribe, opens a UDP proxy session if none exists (binds to the least-loaded game server); open/transport failures are delivered as RealtimeConnectionEvent (code UDP_PROXY_CONNECTION_FAILED) and then the stream ends. Only this app’s spatial fan-out is delivered; appId-less control frames always pass. Subscribe before/while sending so async results are not missed. Unsubscribing stops delivery only — it does NOT close the UDP session; call disconnectUdpProxy (or rely on the server inactivity timeout) to release it.

{crowdypy-0.5.1.dev1 → crowdypy-0.6.0.dev1}/src/crowdypy/__init__.py

@@ -95,6 +95,7 @@ _LAZY: dict[str, str] = {
     "PortalConsentRequiredError": "crowdypy.domains.portal",
     "default_hosted_sign_in_url": "crowdypy.domains.portal",
     "is_hosted_sign_in_required_error": "crowdypy.domains.portal",
+    "is_legal_acceptance_required_error": "crowdypy.domains.portal",
     "AuthResponse": "crowdypy.domains.auth",
     "is_already_registered_error": "crowdypy.domains.auth",
     "is_invalid_current_password_error": "crowdypy.domains.auth",
@@ -330,6 +331,9 @@ if TYPE_CHECKING:
     from crowdypy.domains.portal import (
         is_hosted_sign_in_required_error as is_hosted_sign_in_required_error,
     )
+    from crowdypy.domains.portal import (
+        is_legal_acceptance_required_error as is_legal_acceptance_required_error,
+    )
     from crowdypy.domains.quotas import (
         QuotasAPI as QuotasAPI,
     )

{crowdypy-0.5.1.dev1 → crowdypy-0.6.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: f00952f685420f6c0f4bf58d56debda29aea8cce9b877754393611393ff63db1
+schema.gql sha256: 29d59267d8bf5a0497b272ac22b5edfb702c4872087b0cffaa1542a81c917834
 """
 
 from enum import StrEnum