Filter disabled relays from publish paths (broadcast, non-broadcast, and raw)

www/js/version.json

@@ -1,5 +1,5 @@
 {
-  "VERSION": "v0.7.100",
-  "VERSION_NUMBER": "0.7.100",
-  "BUILD_DATE": "2026-08-07T10:54:50.095Z"
+  "VERSION": "v0.7.101",
+  "VERSION_NUMBER": "0.7.101",
+  "BUILD_DATE": "2026-08-07T14:06:51.088Z"
 }

www/ndk-worker.js

@@ -89728,6 +89728,17 @@ let disabledRelays = new Set();
 // auto-connecting to discovered outbox relays.
 let outboxModelEnabled = true;
 
+/**
+ * Check if a relay URL is temporarily disabled.
+ * Checks both the normalized and raw form.
+ */
+function isRelayDisabled(relayUrl) {
+    if (!relayUrl) return false;
+    if (disabledRelays.has(relayUrl)) return true;
+    const normalized = normalizeRelayUrl(relayUrl);
+    return normalized && disabledRelays.has(normalized);
+}
+
 // App-wide user settings state
 const USER_SETTINGS_DB_NAME = 'ndk-shared-settings';
 const USER_SETTINGS_DB_VERSION = 2;
@@ -95693,9 +95704,12 @@ async function handlePublish(requestId, event, port) {
         if (isBroadcast) {
             outboxWriteUrls = Array.from(relayTypes.entries())
                 .filter(([, t]) => t === 'write' || t === 'both')
-                .map(([url]) => url);
+                .map(([url]) => url)
+                .filter(url => !isRelayDisabled(url)); // exclude disabled relays
         }
-        const allBroadcastUrls = [...new Set([...outboxWriteUrls, ...activeBroadcastUrls])];
+        // Filter disabled relays from broadcast URLs too
+        const activeBroadcastUrlsFiltered = activeBroadcastUrls.filter(url => !isRelayDisabled(url));
+        const allBroadcastUrls = [...new Set([...outboxWriteUrls, ...activeBroadcastUrlsFiltered])];
 
         // --- Live broadcast progress streaming ------------------------------------
         // NDK's NDKEvent emits 'relay:published' and 'relay:publish:failed' per
@@ -95715,7 +95729,7 @@ async function handlePublish(requestId, event, port) {
 
         if (isBroadcast && totalTarget > 0) {
             console.log(`[Worker] Broadcasting to ${allBroadcastUrls.length} relays ` +
-                `(${activeBroadcastUrls.length} broadcast + ${outboxWriteUrls.length} outbox, ` +
+                `(${activeBroadcastUrlsFiltered.length} broadcast + ${outboxWriteUrls.length} outbox, ` +
                 `${skippedRelayUrls.size} skipped)`);
 
             broadcast({
@@ -95825,7 +95839,7 @@ async function handlePublish(requestId, event, port) {
             // --- Phase 2: Broadcast to remaining relays in batches (background) ---
             // Only publish to relays that aren't already in the outbox set
             // (those were already published in Phase 1).
-            const broadcastOnlyUrls = activeBroadcastUrls.filter(u => !outboxWriteUrls.includes(u));
+            const broadcastOnlyUrls = activeBroadcastUrlsFiltered.filter(u => !outboxWriteUrls.includes(u));
             if (broadcastOnlyUrls.length > 0) {
                 const batches = [];
                 for (let i = 0; i < broadcastOnlyUrls.length; i += BATCH_SIZE) {
@@ -95945,12 +95959,34 @@ async function handlePublish(requestId, event, port) {
             // broadcasts since we've handled everything here.
             return;
         } else {
-            // Normal (non-broadcast) publish — await the full result as before.
-            try {
-                relaySet = await ndkEvent.publish(null, undefined, undefined);
-            } catch (publishError) {
-                console.warn('[Worker] publish() threw:', publishError?.message || publishError);
+            // Normal (non-broadcast) publish.
+            // Build a relay set that excludes disabled relays so we don't
+            // publish to (or reconnect) temporarily disabled relays.
+            const enabledRelayUrls = Array.from(ndk.pool.relays.values())
+                .filter(r => !isRelayDisabled(r.url))
+                .map(r => r.url);
+
+            if (enabledRelayUrls.length > 0 && NDKRelaySet?.fromRelayUrls) {
+                console.log(`[Worker] Publishing to ${enabledRelayUrls.length} enabled relays (excluding ${ndk.pool.relays.size - enabledRelayUrls.length} disabled)`);
+                try {
+                    const enabledSet = NDKRelaySet.fromRelayUrls(enabledRelayUrls, ndk);
+                    relaySet = await ndkEvent.publish(enabledSet, undefined, undefined);
+                } catch (publishError) {
+                    console.warn('[Worker] publish() threw:', publishError?.message || publishError);
+                    relaySet = null;
+                }
+            } else if (enabledRelayUrls.length === 0 && ndk.pool.relays.size > 0) {
+                // All relays are disabled — don't publish at all
+                console.warn('[Worker] All relays are disabled — skipping publish');
                 relaySet = null;
+            } else {
+                // Fallback: no relay set builder, use default publish
+                try {
+                    relaySet = await ndkEvent.publish(null, undefined, undefined);
+                } catch (publishError) {
+                    console.warn('[Worker] publish() threw:', publishError?.message || publishError);
+                    relaySet = null;
+                }
             }
         }
 
@@ -96001,9 +96037,9 @@ async function handlePublish(requestId, event, port) {
             // for display purposes, but keep them distinguishable for skip-marking.
             relayResults.failed = [...Array.from(failedSoFar), ...Array.from(timedOutSoFar)];
         } else {
-            // Check which connected relays didn't accept it
+            // Check which connected relays didn't accept it (skip disabled relays)
             for (const relay of ndk.pool.relays.values()) {
-                if (relay.status >= 5 && !relayResults.successful.includes(relay.url)) {
+                if (relay.status >= 5 && !isRelayDisabled(relay.url) && !relayResults.successful.includes(relay.url)) {
                     relayResults.failed.push(relay.url);
                 }
             }
@@ -96111,7 +96147,20 @@ async function handlePublishRaw(requestId, event, port) {
         const ndkEvent = new NDKEvent(ndk, event);
 
         // Do not sign here: raw event is expected to be fully finalized already.
-        const relaySet = await ndkEvent.publish();
+        // Build a relay set that excludes disabled relays.
+        const enabledRelayUrlsRaw = Array.from(ndk.pool.relays.values())
+            .filter(r => !isRelayDisabled(r.url))
+            .map(r => r.url);
+
+        let relaySet = null;
+        if (enabledRelayUrlsRaw.length > 0 && NDKRelaySet?.fromRelayUrls) {
+            const enabledSetRaw = NDKRelaySet.fromRelayUrls(enabledRelayUrlsRaw, ndk);
+            relaySet = await ndkEvent.publish(enabledSetRaw);
+        } else if (enabledRelayUrlsRaw.length === 0 && ndk.pool.relays.size > 0) {
+            console.warn('[Worker] All relays are disabled — skipping raw publish');
+        } else {
+            relaySet = await ndkEvent.publish();
+        }
 
         const relayResults = {
             successful: [],
@@ -96126,7 +96175,7 @@ async function handlePublishRaw(requestId, event, port) {
         }
 
         for (const relay of ndk.pool.relays.values()) {
-            if (relay.status >= 5 && !relayResults.successful.includes(relay.url)) {
+            if (relay.status >= 5 && !isRelayDisabled(relay.url) && !relayResults.successful.includes(relay.url)) {
                 relayResults.failed.push(relay.url);
             }
         }