@crowdedkingdoms/crowdy-dsh 0.4.12 → 0.4.13-dev.1

package/dist/dsh-web/BUILD.json

@@ -1,10 +1,10 @@
 {
   "package": "@crowdedkingdoms/crowdy-dsh",
-  "version": "0.4.12",
-  "builtAt": "2026-10-24T14:23:55.299Z",
+  "version": "0.4.13",
+  "builtAt": "2026-10-24T21:54:31.702Z",
   "source": {
     "repository": "CrowdedKingdoms/crowdy-dsh",
-    "commit": "da2e4b36025c6f7944bbcf0ed799fabf05c5c044",
+    "commit": "a2422f393aebc79753ac80845ed0cee1cb05974e",
     "dirty": false
   },
   "upstream": {
@@ -15,7 +15,7 @@
   },
   "crowdyjs": {
     "name": "@crowdedkingdoms/crowdyjs",
-    "version": "18.19.0",
+    "version": "18.20.0-dev.1",
     "source": "node_modules"
   },
   "files": {
@@ -112,7 +112,7 @@
     "manifest.webmanifest": "sha256:9b54d57eea00f2fdd1affe6e7999a4209a515755f12ac1a3299da2d55e178d4c",
     "preview/bootstrap-CYECZNXt.js": "sha256:9f303a0485c0badfdd19fad0c357ef050c5b9a343744ab5bf0c70015e7d95092",
     "preview/crowdy-boot-Cklh1qNl.js": "sha256:b21e8eb126e1cd8a52159d2d577e610df6c8af36a436f9ed5028cfabd11a85ff",
-    "preview/vfs-image.tar.gz": "sha256:e7cccb795f5739e08bdfcd1e34e456a91268de63e3a1131bcddfa540d8e44800",
+    "preview/vfs-image.tar.gz": "sha256:32fca538762a73aa62017254efeaeadbede6ae134d9289fa0f0a5b2d5892daca",
     "preview/worker-C8-_ANaz.js": "sha256:81099e5732dfe0c32bacd5897316b7956c5a0a22da01b4a0c6e21d0a3b9d9aa1"
   }
 }

package/lib/vendor/crowdyjs-sdk.js

@@ -6752,6 +6752,7 @@ var RealtimeClient = class {
     this.statusListeners = /* @__PURE__ */ new Set();
     this.subscribers = /* @__PURE__ */ new Map();
     this.pending = /* @__PURE__ */ new Map();
+    this.sessionEpochValue = 0;
     this.nextSubscriberId = 1;
     this.subscribedAppId = null;
     this.opening = null;
@@ -6961,16 +6962,69 @@ var RealtimeClient = class {
     });
   }
   waitForSequence(sequenceNumber, timeoutMs = this.waitTimeoutMs) {
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.removePending(sequenceNumber, wait);
-        reject(new CrowdyRealtimeError(`Timed out waiting for UDP response sequence ${sequenceNumber}`, { code: "UDP_SEQUENCE_TIMEOUT", retryable: true }));
-      }, timeoutMs);
-      const wait = { resolve, reject, timer };
-      const waits = this.pending.get(sequenceNumber) ?? [];
-      waits.push(wait);
-      this.pending.set(sequenceNumber, waits);
+    const wait = this.expectSequence(sequenceNumber, timeoutMs);
+    wait.start();
+    return wait.promise;
+  }
+  /**
+   * Register a wait for `sequenceNumber` now and start its clock later.
+   *
+   * An awaited send registers before it sends, so an echo that arrives before
+   * the send's own response is not missed, and calls `start()` once the send has
+   * been accepted: the time the send leg took (a lazy proxy-session open, the
+   * binary relay's handshake) is then not taken from the echo's window.
+   * {@link waitForSequence} is this with the clock started at once.
+   *
+   * @param sequenceNumber - The uint8 sequence the response will carry.
+   * @param timeoutMs - How long to wait once started; defaults to
+   *   {@link RealtimeConfig.waitTimeoutMs}.
+   */
+  expectSequence(sequenceNumber, timeoutMs = this.waitTimeoutMs) {
+    let settled = false;
+    let wait;
+    const promise = new Promise((resolve, reject) => {
+      wait = {
+        resolve: (notification) => {
+          settled = true;
+          resolve(notification);
+        },
+        reject: (error) => {
+          settled = true;
+          reject(error);
+        }
+      };
     });
+    promise.catch(() => void 0);
+    const waits = this.pending.get(sequenceNumber) ?? [];
+    waits.push(wait);
+    this.pending.set(sequenceNumber, waits);
+    return {
+      promise,
+      start: () => {
+        if (settled || wait.timer !== void 0)
+          return;
+        wait.timer = setTimeout(() => {
+          this.removePending(sequenceNumber, wait);
+          wait.reject(new CrowdyRealtimeError(`Timed out waiting for UDP response sequence ${sequenceNumber}`, { code: "UDP_SEQUENCE_TIMEOUT", retryable: true }));
+        }, timeoutMs);
+      },
+      cancel: () => {
+        if (wait.timer !== void 0)
+          clearTimeout(wait.timer);
+        settled = true;
+        this.removePending(sequenceNumber, wait);
+      }
+    };
+  }
+  /**
+   * How many times this client's realtime session has been established: every
+   * transition into `connected` (the first connect, each reconnect) and every
+   * move to another instance counts one. An awaited send compares it with the
+   * epoch of its last confirmed response to know it is the first send of a new
+   * session.
+   */
+  sessionEpoch() {
+    return this.sessionEpochValue;
   }
   /**
    * Whether the binary relay transport is currently active and able to carry
@@ -7265,6 +7319,7 @@ var RealtimeClient = class {
         this.wsUrl = wsUrl;
         this.binaryRelayUrl = deriveBinaryRelayUrl(wsUrl);
         this.connectFailures = 0;
+        this.sessionEpochValue += 1;
         this.restartBinaryRelay();
         if (opts.moveNow)
           this.restartGraphqlSubscription();
@@ -7358,6 +7413,7 @@ var RealtimeClient = class {
     this.wsUrl = target.wsUrl;
     this.binaryRelayUrl = deriveBinaryRelayUrl(target.wsUrl);
     this.connectFailures = 0;
+    this.sessionEpochValue += 1;
     this.onEndpointMove?.({ httpUrl: target.httpUrl, wsUrl: target.wsUrl });
     this.restartBinaryRelay();
   }
@@ -7522,6 +7578,8 @@ var RealtimeClient = class {
     if (status === this.statusValue)
       return;
     this.statusValue = status;
+    if (status === "connected")
+      this.sessionEpochValue += 1;
     for (const listener of [...this.statusListeners]) {
       listener(status);
     }
@@ -7644,9 +7702,11 @@ var ActorClient = class {
    * applied echo — your own `ActorUpdateNotification` (the sender is included in
    * the chunk fan-out), correlated by `sequenceNumber`.
    *
-   * The **first** spatial message to a brand-new chunk may be dropped
-   * server-side while grid permissions load, so if this rejects with a timeout,
-   * simply call `join` again (the two-client tests register twice).
+   * The game server holds the first message into a newly entered region until
+   * its permissions load (realtime server v0.42.0 and later). Against an older
+   * server the first awaited send of each session is retried once (see
+   * `UdpAPI.sendActorUpdateAndWait`); if `join` still rejects with a timeout,
+   * call it again.
    *
    * @param chunk - The chunk to enter, `{ x, y, z }` with each axis a signed
    *   int64 decimal string. A chunk is a 16x16x16 voxel cube.
@@ -17184,6 +17244,7 @@ var UdpAPI = class {
     this.waitForGameplayTokenRefresh = waitForGameplayTokenRefresh;
     this.sequences = new SequenceAllocator();
     this.inFlightActorUpdates = /* @__PURE__ */ new Set();
+    this.confirmedEpoch = -1;
   }
   /**
    * Resolves when every in-flight {@link sendActorUpdate} has settled.
@@ -17370,8 +17431,22 @@ var UdpAPI = class {
    * @param input - {@link ActorUpdateRequestInput} (see {@link sendActorUpdate}
    *   for field units/encoding). Omit `sequenceNumber` to let the SDK allocate
    *   one.
-   * @param options - `timeoutMs`: how long to wait for the echo, in
-   *   milliseconds; defaults to the client's realtime `waitTimeoutMs` (5000).
+   * Every `send*AndWait` behaves as follows:
+   * - `timeoutMs` counts from when the send was accepted, not from the call, so
+   *   a slow send leg (the first send opening the proxy session, the binary
+   *   relay finishing its handshake) does not shorten the wait for the echo.
+   * - The first awaited send of a new session (the first connect, a reconnect,
+   *   a move to another instance) is retried once with a fresh sequence number
+   *   if it is refused `UNAUTHORIZED` or, for the actor and voxel updates the
+   *   server echoes, if its echo times out (`UDP_SEQUENCE_TIMEOUT`), which is
+   *   how a game server older than v0.42.0 answers a session's first messages;
+   *   the resolved notification then carries the retry's sequence number. A
+   *   send whose `sequenceNumber` you chose is not retried, and neither is the
+   *   timeout of an audio, text or event send, which is how those succeed.
+   *
+   * @param options - `timeoutMs`: how long to wait for the echo once the send
+   *   is accepted, in milliseconds; defaults to the client's realtime
+   *   `waitTimeoutMs` (5000).
    * @returns The correlated {@link SpatialNotification} (your own
    *   `ActorUpdateNotification` self-echo).
    * @throws {CrowdyGraphQLError} if the underlying send is rejected.
@@ -17379,7 +17454,8 @@ var UdpAPI = class {
    *   request timeout.
    * @throws {CrowdyRealtimeError} if no echo arrives within `timeoutMs`
    *   (`code === 'UDP_SEQUENCE_TIMEOUT'`, retryable), or the server returns a
-   *   matching `GenericErrorResponse` (its `code` is the server's `errorCode`).
+   *   matching `GenericErrorResponse` (its `code` is the server's `errorCode`),
+   *   after the one retry described above when it applies.
    * @example
    * ```ts
    * const unsubscribe = client.udp.subscribe({}, appId); // echoes need an open WS
@@ -17394,11 +17470,7 @@ var UdpAPI = class {
    * ```
    */
   async sendActorUpdateAndWait(input, options = {}) {
-    const request = this.withSequence(input);
-    const wait = this.subs.waitForSequence(request.sequenceNumber, options.timeoutMs);
-    await this.sendActorUpdate(request);
-    this.subs.flushSends();
-    return wait;
+    return this.sendAndWait(input, options.timeoutMs, true, (request) => this.sendActorUpdate(request));
   }
   /**
    * Send a single voxel (block) update for spatial replication to nearby
@@ -17465,11 +17537,7 @@ var UdpAPI = class {
    *   (its `code` is the server's `errorCode`).
    */
   async sendVoxelUpdateAndWait(input, options = {}) {
-    const request = this.withSequence(input);
-    const wait = this.subs.waitForSequence(request.sequenceNumber, options.timeoutMs);
-    await this.sendVoxelUpdate(request);
-    this.subs.flushSends();
-    return wait;
+    return this.sendAndWait(input, options.timeoutMs, true, (request) => this.sendVoxelUpdate(request));
   }
   /**
    * Send a spatial voice/audio packet, fanned out to nearby actors as a
@@ -17528,11 +17596,7 @@ var UdpAPI = class {
    *   `errorCode`, e.g. `UNAUTHORIZED` for a missing voice permission).
    */
   async sendAudioPacketAndWait(input, options = {}) {
-    const request = this.withSequence(input);
-    const wait = this.subs.waitForSequence(request.sequenceNumber, options.timeoutMs);
-    await this.sendAudioPacket(request);
-    this.subs.flushSends();
-    return wait;
+    return this.sendAndWait(input, options.timeoutMs, false, (request) => this.sendAudioPacket(request));
   }
   /**
    * Send ONE webcam video fragment, fanned out to nearby actors as a
@@ -17643,11 +17707,7 @@ var UdpAPI = class {
    *   `errorCode`).
    */
   async sendTextPacketAndWait(input, options = {}) {
-    const request = this.withSequence(input);
-    const wait = this.subs.waitForSequence(request.sequenceNumber, options.timeoutMs);
-    await this.sendTextPacket(request);
-    this.subs.flushSends();
-    return wait;
+    return this.sendAndWait(input, options.timeoutMs, false, (request) => this.sendTextPacket(request));
   }
   /**
    * Send a custom, app-defined client event for spatial replication to nearby
@@ -17704,11 +17764,7 @@ var UdpAPI = class {
    *   `errorCode`).
    */
   async sendClientEventAndWait(input, options = {}) {
-    const request = this.withSequence(input);
-    const wait = this.subs.waitForSequence(request.sequenceNumber, options.timeoutMs);
-    await this.sendClientEvent(request);
-    this.subs.flushSends();
-    return wait;
+    return this.sendAndWait(input, options.timeoutMs, false, (request) => this.sendClientEvent(request));
   }
   /**
    * Send a direct actor-to-actor message, delivered only to the actor whose
@@ -17923,6 +17979,53 @@ var UdpAPI = class {
   subscribe(handlers, appId) {
     return this.subs.subscribe(handlers, appId);
   }
+  /**
+   * What every `send*AndWait` does.
+   *
+   * The wait is registered before the send, so an echo that beats the send's
+   * own response is not missed, and its clock starts once the send has been
+   * accepted, so a lazy proxy-session open or the relay's handshake on the send
+   * leg is not taken from the echo's window.
+   *
+   * The first awaited send of a new session (the first connect, a reconnect, or
+   * a move to another instance) is retried once, with a fresh sequence number,
+   * when it is refused `UNAUTHORIZED` or, for a send the server echoes, when
+   * its echo times out: a game server from before the one that holds a
+   * session's first messages refuses or drops them while the session's
+   * permissions load. A send the server does not echo (audio, text, a client
+   * event) succeeds by timing out, so its timeout is never retried. Only when
+   * the SDK chose the sequence number, because the retry needs one of its own
+   * and a caller who chose theirs is correlating by it.
+   */
+  async sendAndWait(input, timeoutMs, echoed, send) {
+    const epoch = this.subs.sessionEpoch();
+    const retryable = epoch !== this.confirmedEpoch && input.sequenceNumber == null;
+    try {
+      const echo = await this.sendOnceAndWait(this.withSequence(input), timeoutMs, send).catch((error) => {
+        if (!retryable || !isFirstSendFailure(error, echoed))
+          throw error;
+        return this.sendOnceAndWait(this.withSequence({ ...input, sequenceNumber: void 0 }), timeoutMs, send);
+      });
+      this.confirmedEpoch = epoch;
+      return echo;
+    } catch (error) {
+      if (!echoed && isTimeout(error))
+        this.confirmedEpoch = epoch;
+      throw error;
+    }
+  }
+  async sendOnceAndWait(request, timeoutMs, send) {
+    const wait = this.subs.expectSequence(request.sequenceNumber, timeoutMs);
+    try {
+      await send(request);
+    } catch (error) {
+      wait.cancel();
+      throw error;
+    }
+    this.subs.flushSends();
+    wait.start();
+    return wait.promise;
+  }
   withSequence(input) {
     return {
       ...input,
@@ -17930,6 +18033,12 @@ var UdpAPI = class {
     };
   }
 };
+function isFirstSendFailure(error, echoed) {
+  return error instanceof CrowdyRealtimeError && (error.code === "UNAUTHORIZED" || echoed && isTimeout(error));
+}
+function isTimeout(error) {
+  return error instanceof CrowdyRealtimeError && error.code === "UDP_SEQUENCE_TIMEOUT";
+}
 
 var STATUS_FIELDS = `
   configured connected accountLogin accountType owner repo branch githubSha repositorySelection installUrl

package/lib/vendor/crowdyjs-sdk.version.json

@@ -1,5 +1,5 @@
 {
   "name": "@crowdedkingdoms/crowdyjs",
-  "version": "18.19.0",
+  "version": "18.20.0-dev.1",
   "source": "node_modules"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdedkingdoms/crowdy-dsh",
-  "version": "0.4.12",
+  "version": "0.4.13-dev.1",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -94,11 +94,11 @@
   "crowdyDsh": {
     "build": {
       "package": "@crowdedkingdoms/crowdy-dsh",
-      "version": "0.4.12",
-      "builtAt": "2026-10-24T14:23:55.299Z",
+      "version": "0.4.13",
+      "builtAt": "2026-10-24T21:54:31.702Z",
       "source": {
         "repository": "CrowdedKingdoms/crowdy-dsh",
-        "commit": "da2e4b36025c6f7944bbcf0ed799fabf05c5c044",
+        "commit": "a2422f393aebc79753ac80845ed0cee1cb05974e",
         "dirty": false
       },
       "upstream": {
@@ -109,7 +109,7 @@
       },
       "crowdyjs": {
         "name": "@crowdedkingdoms/crowdyjs",
-        "version": "18.19.0",
+        "version": "18.20.0-dev.1",
         "source": "node_modules"
       },
       "files": {
@@ -206,7 +206,7 @@
         "manifest.webmanifest": "sha256:9b54d57eea00f2fdd1affe6e7999a4209a515755f12ac1a3299da2d55e178d4c",
         "preview/bootstrap-CYECZNXt.js": "sha256:9f303a0485c0badfdd19fad0c357ef050c5b9a343744ab5bf0c70015e7d95092",
         "preview/crowdy-boot-Cklh1qNl.js": "sha256:b21e8eb126e1cd8a52159d2d577e610df6c8af36a436f9ed5028cfabd11a85ff",
-        "preview/vfs-image.tar.gz": "sha256:e7cccb795f5739e08bdfcd1e34e456a91268de63e3a1131bcddfa540d8e44800",
+        "preview/vfs-image.tar.gz": "sha256:32fca538762a73aa62017254efeaeadbede6ae134d9289fa0f0a5b2d5892daca",
         "preview/worker-C8-_ANaz.js": "sha256:81099e5732dfe0c32bacd5897316b7956c5a0a22da01b4a0c6e21d0a3b9d9aa1"
       }
     }