@alteriom/painlessmesh 2.0.0 → 2.0.2

package/CHANGELOG.md

@@ -7,6 +7,115 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.2] - 2026-09-08
+
+Two gateway defects that reached users on 2.0.1, both in code the desktop test
+suite cannot compile, and both now asserted on real hardware. **Upgrade if a
+node of yours is a bridge**: on 2.0.1 a bridge could not use its own uplink at
+all, and any request that failed below HTTP was reported to the origin node as
+`HTTP 65535`.
+
+### Fixed
+
+- **A bridge could not reach the Internet through its own uplink** (#445).
+  `sendToInternet()` serves a request locally only when `hasLocalInternet()` is
+  true. That flag is set by the Internet health checker, and `initAsBridge()`
+  never started it — only `initAsSharedGateway()` did — so on a bridge it was
+  false for the life of the node. Every request the bridge itself made fell
+  through to the mesh-routing path and failed with *"No active mesh
+  connections"* whenever no peer had joined yet, which is exactly what a
+  single-node sketch does at start-up. `initAsBridge()` now starts the checker,
+  without touching a `setInternetCheckTarget()` the sketch made before `init()`.
+
+- **A request that never reached a server was reported as `HTTP 65535`** (#446).
+  `HTTPClient` returns an `int`: positive is an HTTP status, negative is one of
+  its own transport errors (`-1` refused, `-11` read timeout). The gateway
+  stored that in a `uint16_t`, so `-1` wrapped to 65535 — a value that passes
+  `httpCode > 0`. Three things followed: the origin node was told "HTTP 65535",
+  the `errorToString()` branch was unreachable, and `handleGatewayAck()` filed a
+  retryable network failure as a permanent HTTP status. A transport failure now
+  arrives as `httpStatus 0` with the real reason in the error string, which is
+  what the origin node already treats as retryable.
+
+- **A lone gateway consumed its retries without issuing a single request.**
+  `retryInternetRequest()` knew only the remote path: it required an active mesh
+  connection and then routed to a discovered bridge, so a gateway serving its
+  own request satisfied neither check and reported *"Max retries exceeded"* in
+  place of the transport error that actually happened — the same dishonest
+  failure as #446, one layer up. A retry whose gateway is this node now goes
+  back to the local handler.
+
+### Changed
+
+- The HTTP result classification moved into `gateway::classifyHttpResult()`, so
+  the desktop test suite exercises the same function `wifi.hpp` calls. The
+  previous test duplicated the classification — and duplicated the `uint16_t`
+  with it, which is why it mirrored #446 instead of catching it.
+
+### Validated
+
+Both fixes are asserted on the ESP32 farm, not only in desktop tests: a bridge
+must report Internet on its own uplink, must relay its own request through it,
+must do so with **no mesh peer at all**, and must return `httpStatus 0` with a
+real reason for a refused port, an unresolvable host and a destination that
+answers past the timeout. Those rows did not exist when 2.0.1 shipped — the
+gateway suite passed on the run that carried both bugs.
+
+
+## [2.0.1] - 2026-09-07
+
+A packaging and documentation release. **No library behaviour changed**: the
+mesh, routing, gateway, failover and OTA code of 2.0.1 is 2.0.0's, and the only
+edit under `src/` is the version macro. It exists to repair two defects in what
+2.0.0 *shipped*, both of which cost a user time before they ever compile
+anything.
+
+### Fixed
+
+- **The installation instructions shipped in 2.0.0 name a PlatformIO package
+  that has no 2.0.0.** The README, user guide and documentation site gave
+  `alteriom/AlteriomPainlessMesh`, and that registry owner stops at 1.10.0 — its
+  account is not one this project can publish from. Every automated release
+  since 1.7.6 went out under `sparck75`, which is now what the documentation
+  names. **Name the owner in `lib_deps`**: the bare name `AlteriomPainlessMesh`
+  matches both owners and PlatformIO warns rather than choosing.
+
+  ```ini
+  lib_deps =
+      sparck75/AlteriomPainlessMesh@^2.0.0
+  ```
+
+- **The v2.0.0 GitHub release carries no library archive.** This repository
+  publishes immutable releases, so the workflow's upload step — which ran after
+  the release was created — was refused with HTTP 422. The job failed before its
+  release decision, which also skipped the npm, GitHub Packages and PlatformIO
+  jobs; those three were published by hand. The archive is now attached in the
+  same call that creates the release, and the decision to publish is taken
+  before any step that can fail, so a failed upload can no longer suppress the
+  publications.
+
+- **PlatformIO publication went under the token's account rather than the
+  organisation.** `pio pkg publish` files a package under the account unless
+  `--owner` names the owner, and the workflow never passed it — which is how the
+  duplicate ownership above arose in the first place. It now passes `--owner`,
+  checks the version against that owner's own version table (the previous check
+  read a `Version:` line `pio pkg show` never prints), publishes the release
+  tag's sources rather than whichever branch was dispatched, and treats an
+  already-listed version as success instead of a failure.
+
+- **`scripts/validate-release.sh` reported a version mismatch that was not
+  there.** Without `jq` it fell back to a grep that matches every `"version"`
+  line in `library.json`, dependencies included, so the value it compared was
+  multi-line. It takes the first match now — the top-level one. CI was never
+  affected; it has `jq`.
+
+### Upgrading
+
+Nothing in the library behaves differently, so upgrading from 2.0.0 is optional.
+Take it if you install through PlatformIO, or if you want the release archive
+attached to the GitHub release. Everything in the 2.0.0 entry below still
+applies, including its *Before you upgrade* section.
+
 ## [2.0.0] - 2026-09-07
 
 painlessMesh 2.0 is a major release. It adds per-message delivery
@@ -317,6 +426,11 @@ processes scan results from the loop for that reason (see the ESP32 entry).
   every PR like the other twenty.
 - `keywords.txt` now lists the bridge, gateway, failover, queue and capacity
   API so the Arduino IDE highlights it.
+- **PlatformIO package owner.** 2.0.0 is published as `sparck75/AlteriomPainlessMesh`,
+  the owner every automated release since 1.7.6 went under. The registry also
+  holds `alteriom/AlteriomPainlessMesh`, which stops at 1.10.0: its account is
+  not one the project can publish from. Name the owner in `lib_deps`; the bare
+  name matches both.
 
 ### Added (post-review series)
 

package/README.md

@@ -11,7 +11,7 @@
 [![Release](https://github.com/Alteriom/painlessMesh/actions/workflows/release.yml/badge.svg)](https://github.com/Alteriom/painlessMesh/actions/workflows/release.yml)
 [![GitHub release](https://img.shields.io/github/v/release/Alteriom/painlessMesh?label=version)](https://github.com/Alteriom/painlessMesh/releases)
 [![NPM Version](https://img.shields.io/npm/v/@alteriom/painlessmesh?label=npm)](https://www.npmjs.com/package/@alteriom/painlessmesh)
-[![PlatformIO Registry](https://badges.registry.platformio.org/packages/alteriom/library/AlteriomPainlessMesh.svg)](https://registry.platformio.org/libraries/alteriom/AlteriomPainlessMesh)
+[![PlatformIO Registry](https://badges.registry.platformio.org/packages/sparck75/library/AlteriomPainlessMesh.svg)](https://registry.platformio.org/libraries/sparck75/AlteriomPainlessMesh)
 
 </div>
 
@@ -410,11 +410,11 @@ git clone https://github.com/Alteriom/painlessMesh.git AlteriomPainlessMesh
 
 ### PlatformIO
 
-The library is published on the [PlatformIO registry](https://registry.platformio.org/libraries/alteriom/AlteriomPainlessMesh) as `alteriom/AlteriomPainlessMesh`:
+The library is published on the [PlatformIO registry](https://registry.platformio.org/libraries/sparck75/AlteriomPainlessMesh) as `sparck75/AlteriomPainlessMesh`. The registry also lists an `alteriom/AlteriomPainlessMesh` that stops at 1.10.0; its owner account is not one the project can publish from, so 2.0.0 and later live under `sparck75`, which has carried every automated release since 1.7.6. Name the owner in `lib_deps`, since the bare name matches both:
 
 ```ini
 lib_deps =
-    alteriom/AlteriomPainlessMesh@^2.0.0
+    sparck75/AlteriomPainlessMesh@^2.0.0
 ```
 
 ### Dependencies
@@ -596,9 +596,13 @@ These are the message types used by applications built on painlessMesh:
 - **Event Coordination** - Synchronized displays, distributed processing
 - **Bridge Networks** - Connect mesh to WiFi/Internet/MQTT - [📖 Bridge Guide](BRIDGE_TO_INTERNET.md)
 
-## Latest Release: v2.0.0 (September 7, 2026)
+## Latest Release: v2.0.2 (September 8, 2026)
 
-**Delivery confirmation, a unified send path, and a mesh that holds together on real hardware**
+**Two gateway fixes — upgrade if any node of yours is a bridge.** On 2.0.1 a bridge could not reach the Internet through its own uplink at all (`initAsBridge()` never started the health checker that `sendToInternet()`'s local path depends on, so a bridge with no peer yet failed with "No active mesh connections"), and any request that failed *below* HTTP — refused, unresolvable, timed out — was reported to the origin node as `HTTP 65535`, a truncated `-1`, which also stopped it from being retried. Both are now asserted on the hardware rig, including a bridge with no mesh peer at all.
+
+**2.0.1 — a packaging fix over 2.0.0, no library behaviour changed.** 2.0.0's installation instructions named a PlatformIO package that has no 2.0.0 (`alteriom/…` stops at 1.10.0; releases go out under `sparck75`), and its GitHub release carried no library archive because the upload was refused by an immutable release.
+
+**2.0.0 — delivery confirmation, a unified send path, and a mesh that holds together on real hardware**
 
 - `sendSingle()` and `sendBroadcast()` accept a delivery callback — it fires with `delivered=true` and the round-trip latency on acknowledgment, or `delivered=false` on timeout — and a `SendOptions` struct that carries a priority and a callback in one call. Priority is kept across hops.
 - Thirty-odd defects in gateway failover, channel following, routing and the station scan, every one found in the serial logs of a six-family hardware rig and fixed there: a bridge that stops says so, the mesh follows an elected bridge to its channel and treats it as home, a node is in one place in every neighbour's tree, a dead connection is not a route, a stale scan does not consume a live one.

package/RELEASE_GUIDE.md

@@ -21,7 +21,12 @@ the version commit reaches `main`.
    workflow owns tags and publication.
 
    The workflow tags only when the push to `main` carries a version-file
-   change or a head commit whose message starts with `release:`. When the
+   change or a head commit whose message starts with `release:`. The
+   repository publishes immutable releases: a release takes its assets and
+   notes when it is created and cannot be edited afterwards, so a failed
+   publication is repaired by `manual-publish.yml` (npm, GitHub Packages) and
+   `platformio-publish.yml`, both dispatched with the tag, not by re-running
+   the release workflow. When the
    version metadata was bumped earlier in the cycle (as for 2.0.0), merge the
    release pull request with a commit titled `release: vX.Y.Z` — a squash or
    merge commit with that title — or the push is ignored.
@@ -77,12 +82,24 @@ The pull request must also pass all required GitHub checks, including:
 - formatting and documentation checks
 - CodeQL
 - simulator scenarios
-- ESP32, ESP32-C3, and ESP32-S3 hardware-in-the-loop coverage when the change
+- hardware-in-the-loop coverage on the six-family board bank when the change
   touches radio, routing, gateway, OTA, or platform-specific behavior
 
-For a hardware defect, attach the HIL run identifier and report link to the
-pull request. A unit test alone is not sufficient evidence for a radio or
-multi-device timing fix.
+### How the hardware result arrives
+
+The Alteriom ESP32 farm is a separate, private repository, so nothing in this
+one triggers it — a public workflow can hold no credential for it. The farm
+watches instead: it picks up `main` and open non-fork pull requests that touch
+`src/`, `examples/`, `test/` or the library metadata, runs the simulator gate
+and then the physical suite, and posts the verdict back as a **`farm/hil`
+commit status** with a link to the run. Expect it within roughly half an hour
+of a push; nothing is required of the author.
+
+For a hardware defect, link that run in the pull request. A unit test alone is
+not sufficient evidence for a radio or multi-device timing fix — and a desktop
+test that re-implements the logic it is checking is not evidence at all
+(`catch_http_status_codes.cpp` copied the `uint16_t` that caused #446 and so
+mirrored the bug instead of catching it).
 
 ## Review gate
 

package/examples/sendToInternet/platformio.ini

@@ -9,7 +9,7 @@ platform = espressif32
 board = esp32dev
 framework = arduino
 lib_deps = 
-    alteriom/AlteriomPainlessMesh
+    sparck75/AlteriomPainlessMesh
     bblanchon/ArduinoJson@^7.0.0
 monitor_speed = 115200
 
@@ -18,6 +18,6 @@ platform = espressif8266
 board = nodemcuv2
 framework = arduino
 lib_deps = 
-    alteriom/AlteriomPainlessMesh
+    sparck75/AlteriomPainlessMesh
     bblanchon/ArduinoJson@^7.0.0
 monitor_speed = 115200

package/library.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/Alteriom/painlessMesh"
   },
-  "version": "2.0.0",
+  "version": "2.0.2",
   "frameworks": [
     "arduino"
   ],

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=2.0.0
+version=2.0.2
 author=Coopdis,Scotty Franzyshen,Edwin van Leeuwen,Germán Martín,Maximilian Schwarz,Doanh Doanh,Alteriom
 maintainer=Alteriom
 sentence=A painless way to setup a mesh with ESP8266 and ESP32 devices with Alteriom extensions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alteriom/painlessmesh",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "painlessMesh is a user-friendly library for creating mesh networks with ESP8266 and ESP32 devices. This Alteriom fork includes additional packages for sensor data (SensorPackage), device commands (CommandPackage), and status monitoring (StatusPackage). It handles routing and network management automatically, so you can focus on your application. The library uses JSON-based messaging and syncs time across all nodes, making it ideal for coordinated behaviour like synchronized light displays or sensor networks reporting to a central node.",
   "keywords": [
     "arduino",

package/src/AlteriomPainlessMesh.h

@@ -29,10 +29,10 @@
 /**
  * @brief AlteriomPainlessMesh library version information
  */
-#define ALTERIOM_PAINLESS_MESH_VERSION "2.0.0"
+#define ALTERIOM_PAINLESS_MESH_VERSION "2.0.2"
 #define ALTERIOM_PAINLESS_MESH_VERSION_MAJOR 2
 #define ALTERIOM_PAINLESS_MESH_VERSION_MINOR 0
-#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 0
+#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 2
 
 /**
  * @brief Library description and usage information

package/src/arduino/wifi.hpp

@@ -492,6 +492,20 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     // Step 6: Setup gateway Internet handler
     initGatewayInternetHandler();
 
+    // Step 7: Start the health checker that drives hasLocalInternet().
+    // Without it that flag stays false for the life of the node, so the
+    // local short-circuit in sendToInternet() never fires and a bridge
+    // asking its own uplink fell through to the mesh-routing path -- which
+    // fails with "No active mesh connections" whenever the bridge has no
+    // peer yet, even though the router link is up (issue #445).
+    // initAsSharedGateway() has always done this; initAsBridge() did not.
+    //
+    // No configureInternetHealthCheck() call here: a bridge has no
+    // SharedGatewayConfig, the checker's own defaults (8.8.8.8:53, 30 s,
+    // 5 s) already match that struct's, and configuring would clobber any
+    // setInternetCheckTarget() the sketch made before init.
+    enableInternetHealthCheck();
+
     Log(STARTUP, "=== Bridge Mode Active ===\n");
     Log(STARTUP, "  Mesh SSID: %s\n", meshSSID.c_str());
     Log(STARTUP, "  Mesh Channel: %d%s\n", detectedChannel, 
@@ -2864,7 +2878,15 @@ class Mesh : public painlessmesh::Mesh<Connection> {
           http.setTimeout(GATEWAY_HTTP_TIMEOUT_MS);
 
           bool success = false;
-          uint16_t httpCode = 0;
+          // HTTPClient returns an int: a positive value is an HTTP status
+          // code, a negative one is its own transport error (HTTPC_ERROR_*,
+          // -1 for a refused connection, -11 for a read timeout, ...). This
+          // was a uint16_t, which wrapped -1 to 65535 -- a value that passes
+          // `httpCode > 0`, so every transport failure was reported to the
+          // origin node as "HTTP 65535" (issue #446), the errorToString()
+          // branch below was unreachable, and handleGatewayAck() classified a
+          // transient network failure as a non-retryable HTTP status.
+          int httpCode = 0;
           TSTRING error = "";
 
 #ifdef ESP8266
@@ -2903,21 +2925,22 @@ class Mesh : public painlessmesh::Mesh<Connection> {
             httpCode = http.GET();
           }
 
-          if (httpCode > 0) {
-            // Only specific 2xx status codes indicate genuine success
-            // 200 OK: Standard successful response
-            // 201 Created: Resource successfully created
-            // 202 Accepted: Request accepted for processing
-            // 204 No Content: Successful with no response body
-            //
-            // Other 2xx codes like 203 (Non-Authoritative Information) often
-            // indicate cached/proxied responses that may not represent actual
-            // delivery to the destination service (e.g., WhatsApp API).
-            //
-            // 3xx redirects are not automatically followed
-            success = (httpCode == 200 || httpCode == 201 || 
-                      httpCode == 202 || httpCode == 204);
-            
+          // Only specific 2xx status codes indicate genuine success:
+          // 200 OK, 201 Created, 202 Accepted, 204 No Content.
+          //
+          // Other 2xx codes like 203 (Non-Authoritative Information) often
+          // indicate cached/proxied responses that may not represent actual
+          // delivery to the destination service (e.g., WhatsApp API).
+          //
+          // 3xx redirects are not automatically followed.
+          //
+          // The classification lives in painlessmesh::gateway so the desktop
+          // test suite can exercise it; this file is ESP-only and never
+          // compiled by the Catch2 build.
+          const auto outcome = gateway::classifyHttpResult(httpCode);
+          success = outcome.success;
+
+          if (!outcome.transportError) {
             if (success) {
               Log(COMMUNICATION, "HTTP request completed: code=%d\n", httpCode);
             } else if (httpCode >= 200 && httpCode < 300) {
@@ -2957,8 +2980,9 @@ class Mesh : public painlessmesh::Mesh<Connection> {
 
           http.end();
 
-          // Send acknowledgment back
-          finish(success, httpCode, error);
+          // Send acknowledgment back. Transport errors carry status 0, the
+          // value handleGatewayAck() treats as a retryable network error.
+          finish(success, outcome.ackStatus, error);
 #else
         // Non-ESP platform - send error
         finish(false, 0, "HTTP client not available on this platform");

package/src/painlessmesh/gateway.hpp

@@ -965,6 +965,54 @@ class GatewayDataPackage : public plugin::SinglePackage {
 
 };
 
+/**
+ * @brief The outcome of a gateway HTTP request, classified for the ack
+ *
+ * HTTPClient::GET()/POST() return an int with two distinct meanings: a
+ * positive value is an HTTP status code from the destination, while a
+ * negative value is one of the client's own transport errors (HTTPC_ERROR_*,
+ * e.g. -1 for a refused connection or -11 for a read timeout). Zero is not
+ * produced by either.
+ *
+ * GatewayAckPackage::httpStatus is a uint16_t, so a negative code cannot be
+ * forwarded as-is. Transport errors are reported as httpStatus 0, which is
+ * what Mesh::handleGatewayAck() already treats as a retryable network error;
+ * the human-readable cause travels in GatewayAckPackage::error instead.
+ */
+struct HttpRequestOutcome {
+  /** True only for status codes that indicate genuine delivery. */
+  bool success = false;
+
+  /** Value to place in GatewayAckPackage::httpStatus (0 for transport errors). */
+  uint16_t ackStatus = 0;
+
+  /** True when the client failed before any HTTP status was received. */
+  bool transportError = false;
+};
+
+/**
+ * @brief Classify an HTTPClient return value for the gateway acknowledgment
+ *
+ * Only 200, 201, 202 and 204 count as success. Other 2xx codes (notably 203,
+ * Non-Authoritative Information) indicate a cached or proxied response rather
+ * than delivery to the destination service, so they are failures.
+ *
+ * @param rawCode The int returned by HTTPClient::GET() or ::POST()
+ * @return Classified outcome, safe to place in a GatewayAckPackage
+ */
+inline HttpRequestOutcome classifyHttpResult(int rawCode) {
+  HttpRequestOutcome outcome;
+  if (rawCode <= 0) {
+    outcome.transportError = true;
+    return outcome;
+  }
+  outcome.ackStatus =
+      static_cast<uint16_t>(rawCode > 0xFFFF ? 0xFFFF : rawCode);
+  outcome.success = (rawCode == 200 || rawCode == 201 || rawCode == 202 ||
+                     rawCode == 204);
+  return outcome;
+}
+
 /**
  * @brief Gateway Acknowledgment Package for delivery confirmations
  *

package/src/painlessmesh/mesh.hpp

@@ -1546,8 +1546,17 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   void enableInternetHealthCheck() {
     using namespace logger;
     if (internetHealthCheckTask != nullptr) {
-      Log(GENERAL, "enableInternetHealthCheck(): Already enabled\n");
-      return;
+      if (internetHealthCheckTask->isEnabled()) {
+        Log(GENERAL, "enableInternetHealthCheck(): Already enabled\n");
+        return;
+      }
+      // A stop()/re-init cycle -- what bridge promotion does before calling
+      // initAsBridge() again -- disables every task and drops it from the
+      // reusable pool, but this member still points at it. Refusing here
+      // would leave a re-initialised node with no health check at all, and
+      // so with hasLocalInternet() stuck false (issue #445). Re-arm instead,
+      // releasing the spent task so the pool can reclaim it.
+      internetHealthCheckTask = nullptr;
     }
     
     Log(GENERAL, "enableInternetHealthCheck(): Starting health check task (interval: %u ms)\n",
@@ -1678,20 +1687,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       request.callback = callback;
       pendingInternetRequests[messageId] = request;
 
-      gateway::GatewayDataPackage pkg;
-      pkg.from = this->nodeId;
-      pkg.dest = this->nodeId;
-      pkg.messageId = messageId;
-      pkg.originNode = this->nodeId;
-      pkg.timestamp = this->getNodeTime();
-      pkg.priority = priority;
-      pkg.destination = destination;
-      pkg.payload = payload;
-      pkg.contentType = "application/json";
-      pkg.retryCount = 0;
-      pkg.requiresAck = true;
-      protocol::Variant variant(&pkg);
-      this->callbackList.execute(protocol::GATEWAY_DATA, variant, nullptr, 0);
+      dispatchInternetRequestLocally(messageId, priority, 0, destination,
+                                     payload);
       return messageId;
     }
 
@@ -2041,6 +2038,37 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     }
   }
 
+  /**
+   * Run a gateway request against this node's own uplink
+   *
+   * The package goes to this node's own GATEWAY_DATA handler, so the
+   * acknowledgment, pending-request tracking and callback semantics stay
+   * identical to a request served by a peer gateway.
+   *
+   * The handler runs synchronously and its acknowledgment can erase the
+   * pending entry, so callers must not hold a reference into
+   * pendingInternetRequests across this call -- pass copies.
+   */
+  void dispatchInternetRequestLocally(uint32_t messageId, uint8_t priority,
+                                      uint8_t retryCount,
+                                      const TSTRING& destination,
+                                      const TSTRING& payload) {
+    gateway::GatewayDataPackage pkg;
+    pkg.from = this->nodeId;
+    pkg.dest = this->nodeId;
+    pkg.messageId = messageId;
+    pkg.originNode = this->nodeId;
+    pkg.timestamp = this->getNodeTime();
+    pkg.priority = priority;
+    pkg.destination = destination;
+    pkg.payload = payload;
+    pkg.contentType = "application/json";
+    pkg.retryCount = retryCount;
+    pkg.requiresAck = true;
+    protocol::Variant variant(&pkg);
+    this->callbackList.execute(protocol::GATEWAY_DATA, variant, nullptr, 0);
+  }
+
   /**
    * Schedule retry for a failed Internet request
    */
@@ -2087,6 +2115,28 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
 
     PendingInternetRequest& request = it->second;
 
+    // A request this node is serving from its own uplink never had a mesh
+    // hop to repeat. The routing path below needs an active peer and a
+    // discovered bridge, so a lone gateway would burn every retry without
+    // issuing a single HTTP request and then report "Max retries exceeded"
+    // in place of the transport error that actually occurred -- the same
+    // dishonest failure issue #446 was about.
+    //
+    // Copy what the redispatch needs first: the local handler runs
+    // synchronously and can erase this entry, leaving `request` dangling.
+    if (request.gatewayNodeId == this->nodeId && hasLocalInternet()) {
+      const uint8_t priority = request.priority;
+      const uint8_t retryCount = request.retryCount;
+      const TSTRING destination = request.destination;
+      const TSTRING payload = request.payload;
+      Log(logger::COMMUNICATION,
+          "retryInternetRequest(): Retrying msgId=%u on the local uplink\n",
+          messageId);
+      dispatchInternetRequestLocally(messageId, priority, retryCount,
+                                     destination, payload);
+      return;
+    }
+
     // Check mesh connectivity before attempting retry
     // During bridge failover, connection may be temporarily lost
     if (!hasActiveMeshConnections()) {