Skip to content

Jamulus 4.0.0beta1 (and -6) seems to hang occasionally in connect dialog #3758

Closed

Description

@ann0see

Describe the bug

Jamulus 4.0.0 beta1 seems to hang on macOS while fetching the server list. This might be a deadlock
To Reproduce

  • Connect to a server
  • Open connect dialog via File->connect
  • Sometimes observe that Jamulus hangs. This might occur if one switches directories often in the UI

Expected behavior
No hang

Trace

It seems as if the hang might occur in CLMessReadyForSending:

12  QCoreApplication::sendEvent(QObject*, QEvent*) + 172 (QtCore + 625164) [0x107004a0c] 1-12
                                              12  QApplication::notify(QObject*, QEvent*) + 3084 (QtWidgets + 70888) [0x105c494e8] 1-12
                                                12  QApplicationPrivate::notify_helper(QObject*, QEvent*) + 332 (QtWidgets + 64136) [0x105c47a88] 1-12
                                                  12  QWidget::event(QEvent*) + 3200 (QtWidgets + 390252) [0x105c9746c] 1-12
                                                    12  QObject::event(QEvent*) + 672 (QtCore + 929364) [0x10704ee54] 1-12
                                                      12  ??? (Jamulus + 997264) [0x104beb790] 1-12
                                                        12  CProtocol::CreateCLPingWithNumClientsMes(CHostAddress const&, int, int) + 116 (Jamulus + 155652) [0x104b1e004] 1-12
                                                          12  CProtocol::CreateAndImmSendConLessMessage(int, CVector<unsigned char> const&, CHostAddress const&) + 152 (Jamulus + 134384) [0x104b18cf0] 1-12
                                                            12  CProtocol::CLMessReadyForSending(CHostAddress, CVector<unsigned char>) + 56 (Jamulus + 1406932) [0x104c4f7d4] 1-12
                                                              12  ??? (QtCore + 963772) [0x1070574bc] 1-12
                                                                12  ??? (Jamulus + 623968) [0x104b90560] 1-12
                                                                  12  ??? (Jamulus + 624200) [0x104b90648] 1-12
                                                                    12  __sendmsg + 8 (libsystem_kernel.dylib + 27008) [0x18228b980] 1-12
                                                                     *12  ??? (kernel.release.t6041 + 24220) [0xfffffe000b739e9c] 1-12
                                                                       *12  ??? (kernel.release.t6041 + 1923588) [0xfffffe000b909a04] 1-12
                                                                         *12  ??? (kernel.release.t6041 + 7742628) [0xfffffe000be964a4] 1-12
                                                                           *12  ??? (kernel.release.t6041 + 6768432) [0xfffffe000bda8730] 1-12
                                                                             *12  ??? (kernel.release.t6041 + 6767100) [0xfffffe000bda81fc] 1-12
                                                                               *12  sosend + 1044 (kernel.release.t6041 + 6696948) [0xfffffe000bd96ff4] 1-12
                                                                                 *12  ??? (kernel.release.t6041 + 6695552) [0xfffffe000bd96a80] 1-12
                                                                                   *12  ??? (kernel.release.t6041 + 6744736) [0xfffffe000bda2aa0] 1-12
                                                                                     *12  ??? (kernel.release.t6041 + 6334440) [0xfffffe000bd3e7e8] 1-12
                                                                                       *12  lck_mtx_sleep + 212 (kernel.release.t6041 + 481724) [0xfffffe000b7a99bc] 1-12
                                                                                         *12  ??? (kernel.release.t6041 + 590028) [0xfffffe000b7c40cc] 1-12
                                                                                           *12  ??? (kernel.release.t6041 + 595068) [0xfffffe000b7c547c] 1-12

Operating system

macOS 26.5.1

Version of Jamulus

Jamulus 4.0.0 beta1
Additional context

Might be some multithreading bug? Cannot reproduce it consistently for now.

Activity

  1. ann0see commented on Jun 28, 2026

    @ann0see
    MemberAuthor

    Could this be related to some corrupt packet or packet loss (I doubt this though)? I switched between Rock/Jazz directories repeatedly and could sometimes cause the hang. If I let the debugger continue, it recovers.

    it might hang during sending PROTMESSID_CLM_PING_MS_WITHNUMCLIENTS. It may or may not be related to the recent change to BSD/macOS in send_to_ipv4_with_tos.

  2. pljones commented on Jun 29, 2026

    @pljones
    Collaborator

    Is this new with 4.0.0 beta1 or is it reproducible on 3.12.2?

  3. ann0see commented on Jun 29, 2026

    @ann0see
    MemberAuthor

    I could not reproduce it in 3.12.2, just 4.0.0beta1. Let me check what happens if I disable ipv6.

  4. ann0see commented on Jun 29, 2026

    @ann0see
    MemberAuthor

    Yes, I think it does not occur if I disable ipv6. And it does seem to be reproducible in 3.12.2,3.11.0 with -6.
    3.8.1 I could not reproduce for now. But it's an intel build.

  5. softins commented on Jun 29, 2026

    @softins
    Member

    In socket.cpp, find these lines:

    #if defined( Q_OS_BSD4 )
                        // In macOS and FreeBSD we need to set TOS explicitly when sending IPv4 over IPv6 socket
                        status = sendto_ipv4_with_tos ( UdpSocket,
                                                        (const char*) &( (CVector<uint8_t>) vecbySendBuf )[0],
                                                        iVecSizeOut,
                                                        0,
                                                        &UdpSocketAddr.sa,
                                                        sizeof ( UdpSocketAddr.sa6 ),
                                                        (int) iQosNumber );
    #else
                        status = sendto ( UdpSocket,
                                          (const char*) &( (CVector<uint8_t>) vecbySendBuf )[0],
                                          iVecSizeOut,
                                          0,
                                          &UdpSocketAddr.sa,
                                          sizeof ( UdpSocketAddr.sa6 ) );
    #endif
    

    and add && 0 to the #if temporarily and recompile. That will use standard sendto() always, although TOS on IPv4 will not work when IPv6 is enabled. See if the hang no longer occurs.

  6. ann0see commented on Jun 29, 2026

    @ann0see
    MemberAuthor

    I'll try it. However, 3.10.0 (with -6) definitely hangs also on the Jazz genre. I think it doesn't occur before as we read a different config file.

  7. softins commented on Jun 29, 2026

    @softins
    Member

    I'll try it. However, 3.10.0 (with -6) definitely hangs also on the Jazz genre. I think it doesn't occur before as we read a different config file.

    Interesting, since 3.10.0 long predates the use of sendmsg()

  8. ann0see commented on Jun 29, 2026

    @ann0see
    MemberAuthor

    Yes. Also with the && 0 it does still hang

  9. softins commented on Jun 29, 2026

    @softins
    Member

    I wonder if a Wireshark capture will offer any insight?

  10. ann0see commented on Jun 29, 2026

    @ann0see
    MemberAuthor

    Will try.

  11. ann0see commented on Jun 29, 2026

    @ann0see
    MemberAuthor

    Jazz -> classical hang: until no. 502 (filtered for Jamulus protocol).
    pause thread -> code is at _sendto with your change appended.
    continue in Xcode, works again, change to Jazz -> hangs again.
    Now seems to hang forever.

    Will send the pcap to team mail.

  12. ann0see commented on Jun 29, 2026

    @ann0see
    MemberAuthor

    Last UDP payload: 0000f303001300021000332e31322e312d4a414d46414e2d3130138e

  13. 23 remaining items

  14. ann0see commented on Jul 2, 2026

    @ann0see
    MemberAuthor

    GPT did some simulation and believes that it's priority invasion by the audio thread (but I wasn't always connected to a server - so I'm unsure if this actually holds!).

    ## macOS UDP send + mutex contention causes multi-second real-time thread starvation
    
    We reproduced severe real-time audio thread latency spikes on macOS (26.x) using a Jamulus-like UDP sender with socket lifecycle recreation and mutex-protected send path.
    
    ### Key findings
    
    * Audio thread latency spikes up to **~3.3 seconds**
    * Spike breakdown shows:
    
      * `pthread_mutex_lock()` accounts for **~100% of stall time**
      * `sendto()` consistently fast (**~0.05–0.1 ms**) and not the cause
    * Throughput remains stable (~12k packets/sec), so this is **latency-only failure**
    * Spikes correlate strongly with **socket reinitialization (Init/rebind simulation)**
    
    ### Observed worst case
    
    * Audio thread blocked for **3332 ms**
    * Mutex held during lifecycle events for **~1.6 s**
    * Immediate post-REINIT amplification of contention
    
    ### Conclusion
    
    This is not a UDP or IPv4/IPv6 stack issue. The failure mode is:
    
    > **real-time thread starvation caused by long mutex critical sections around shared socket state, amplified by socket reinitialization under concurrent send load**
    
    The behavior is consistent with **priority inversion / scheduling starvation** affecting high-priority audio callback threads when they contend on a shared mutex with network/lifecycle threads.
    
    ### Minimal reproduction conditions
    
    * Single shared UDP socket (IPv4-mapped IPv6 or dual-stack)
    * Multiple threads calling `sendto()`
    * Mutex protecting socket access
    * Periodic socket close/recreate while traffic is active
    * Real-time rate thread (~480 Hz equivalent)
    
    ### Impact
    
    This can cause:
    
    * Audio dropouts / freezes
    * Multi-second UI/audio stalls
    * Non-deadlocking but severe real-time scheduling degradation
    
  15. softins commented on Jul 3, 2026

    @softins
    Member

    I'm still suspicious of the global lock Gemini said macOS uses when managing its dual-stack address mapping.

    I plan to implement separate v4 and v6 sockets within CSocket in the next few days, as time permits. Let's see if that helps.

    There will be other advantages to having separate sockets, such as being able correctly to handle --serverbindip and a new --serverbindip6, and not having to map addresses within Jamulus. It also opens the possibility of adding --noipv4 for a v6-only server in the future.

  16. ann0see commented on Jul 3, 2026

    @ann0see
    MemberAuthor

    I had some local AI analysis (there's not soo much new, but it gives some examples with debugging output)

    Metadata

    • Platform: macOS (tested on macOS 26.5.1 / Darwin 25.5.0)

    Summary

    Jamulus hangs intermittently in the connect dialog on macOS when fetching the server list. The hang occurs inside sendto() when the client attempts to send a packet to a server whose IPv4 address is sent over an IPv6 dual-stack socket using a V4Mapped address (::ffff:x.x.x.x).

    The sendto() syscall blocks in the kernel when the destination is unreachable. While blocked, the socket's send buffer fills and the kernel sleeps waiting for space. The thread holds a QMutex during the entire sendto() call, so any other thread attempting to send blocks on the mutex, creating a deadlock.

    Steps to Reproduce

    1. Build Jamulus with IPv6 support (default).
    2. Connect to a server.
    3. Open the Connect dialog (File → Connect).
    4. Quickly change Directories
    5. The client attempts to send packets to server addresses.
    6. When a server's IPv4 address is sent over the IPv6 dual-stack socket (V4Mapped: ::ffff:a.b.c.d), sendto() may block indefinitely.
    7. The UI freezes; the connect dialog hangs fetching the server list.
      Note: The hang seems to only only occur when IPv6 is enabled (either via -6 flag or by default). With IPv4-only, the hang does not occur.

    Root Cause

    1. IPv6 dual-stack socket + V4Mapped addresses

    The hang occurs when IPv6 is enabled (either via -6 flag or by default). With IPv4-only, the hang does not occur. This confirms the issue is specific to the V4Mapped address path: when bIPv6Available is true, IPv4 destinations are sent via an IPv6 socket using a V4Mapped address (::ffff:x.x.x.x).

    When sendto() is called with a V4Mapped IPv6 address on macOS, and the destination is unreachable (no route, host down, etc.), the kernel does not return EHOSTUNREACH immediately. Instead, the socket is placed in a sleeping state inside the kernel (lck_mtx_sleep via sosend), and the syscall blocks until the send buffer has space or a route is found. This can take minutes or never return.

    2. Mutex held during blocking call

    In CSocket::SendPacket() (socket.cpp:378), a QMutexLocker acquires &Mutex before calling sendto(). The mutex is held for the entire duration of the blocking syscall:

    QMutexLocker locker ( &Mutex );  // socket.cpp:378
    // ...
    status = sendto ( UdpSocket, ... );  // blocks here, mutex still held

    3. Retry loop amplifies the problem

    Note: This might be an invalid AI finding.

    The existing retry loop (socket.cpp:389) retries the send up to 2 times when sendto() fails. If the first sendto() blocks, the retry never executes because the thread is stuck in the kernel.

    4. Stack trace confirmation

    From the original issue trace:

    12  __sendmsg + 8 (libsystem_kernel.dylib + 27008) [0x18228b980]
     12  ??? (kernel.release.t6041 + 24220) [0xfffffe000b739e9c]
     12  ??? (kernel.release.t6041 + 1923588) [0xfffffe000b909a04]
     12  ??? (kernel.release.t6041 + 7742628) [0xfffffe000be964a4]
     12  ??? (kernel.release.t6041 + 6768432) [0xfffffe000bda8730]
     12  ??? (kernel.release.t6041 + 6767100) [0xfffffe000bda81fc]
     12  sosend + 1044 (kernel.release.t6041 + 6696948) [0xfffffe000bd96ff4]
     12  ??? (kernel.release.t6041 + 6695552) [0xfffffe000bd96a80]
     12  ??? (kernel.release.t6041 + 6744736) [0xfffffe000bda2aa0]
     12  ??? (kernel.release.t6041 + 6334440) [0xfffffe000bd3e7e8]
     12  lck_mtx_sleep + 212 (kernel.release.t6041 + 481724) [0xfffffe000b7a99bc]
    

    5. sendto() stops at b.lo assembly instruction

    Te hang occurs inside sendto() at the b.lo (branch-on-lower/unordered) assembly instruction — indicating the kernel is maybe waiting for a route to be found (not "unreachable" in the ICMP sense).

    redundant information removed

    9. Xcode status type warning

    Xcode complains status should be ssize_t not int, but this does not change anything.

    10. Reproducible with -6 flag

    ann0ee confirmed the hang is reproducible in 3.10.0 (with -6) on the Jazz genre, and not reproducible in 3.12.2 without -6.

    Evidence

    Code path (socket.cpp:391-430)

    if ( HostAddr.InetAddr.protocol() == QAbstractSocket::IPv4Protocol )
    {
        if ( bIPv6Available )
        {
            // V4MAPPED address constructed: ::ffff:a.b.c.d
            UdpSocketAddr.sa6.sin6_family = AF_INET6;
            // ...
            addr[2] = htonl ( 0xFFFF );
            addr[3] = htonl ( HostAddr.InetAddr.toIPv4Address() );
    
            status = sendto ( UdpSocket, ... );  // BLOCKS HERE
        }
    }

    Observed 50-second gap (Xcode debugger pause, and continue)

    Debug logging reveals a 50-second gap (which is roughly the time the app is paused in Xcode) where no log lines are produced:

    >> V4MAPPED address constructed  21:02:07.660108
    >> sendto (V4MAPPED) returned    21:02:57.183894
                                   ^^^^^^^^^^^ 50 seconds — process paused in Xcode debugger, not kernel
    
    === SendPacket FAILED === status= -1 errno= 0 strerror= Undefined error: 0 EAGAIN= no EWOULDBLOCK= no socketFD= 7
    socket flags:  2 O_NONBLOCK= NOT SET
    

    Key observations from the reproduction:

    • O_NONBLOCK= NOT SET — the socket is in blocking mode, so sendto blocks in the kernel
    • errno= 0 — macOS does not return a proper error code (like EHOSTUNREACH) for unreachable V4Mapped destinations. Instead, the kernel sleeps and returns -1 with errno=0
    • No log lines during the 50s gap — the process was paused by the Xcode debugger, not blocked in the kernel. The user paused the process, waited 50 seconds, then resumed (unpaused). The kernel did not sleep for 50 seconds.
    • Second retry succeeds in 4ms (57.184 → 57.188) — once the process resumes, sendto returns in milliseconds, proving the kernel was not responsible for the delay

    Execution trace at the point of the hang

    The following log output represents the complete state of the program right before sendto() is called:

    [ 2026-07-03 21:33:42.598 ] === SendPacket ENTER ===
      → status = 0 (initialized, not yet modified)
      → QMutexLocker acquires &Mutex (mutex now LOCKED)
      → iVecSizeOut = 1026
    
    --- SendPacket retry iteration= 0 of 1 ---
      → tries = 0, 0 < 2 → enter for loop
    
    >> Code path: IPv4 destination
      → HostAddr.InetAddr.protocol() == QAbstractSocket::IPv4Protocol → TRUE
    
    >> Sub-path: IPv4 over IPv6 dual-stack socket (V4MAPPED)
      → bIPv6Available = true → TRUE
    
    >> V4MAPPED address constructed: ::ffff: 167.99.132.213
      → UdpSocketAddr.sa6.sin6_family = AF_INET6
      → UdpSocketAddr.sa6.sin6_port = htons(22127)
      → addr[0] = 0, addr[1] = 0
      → addr[2] = htonl(0xFFFF) = 4294901760
      → addr[3] = htonl(167.99.132.213) = 3582223271
      → IN6_IS_ADDR_V4MAPPED(&UdpSocketAddr.sa6.sin6_addr) = true
    

    This is the last log output before the hang. The very next line of code is:

    status = sendto ( UdpSocket, vecbySendBuf.data(), iVecSizeOut, 0,
                      (sockaddr*)&UdpSocketAddr.sa6, sizeof ( UdpSocketAddr.sa6 ) );

    At this point:

    • status = 0 (unchanged — sendto has not returned yet)
    • Mutex is locked by QMutexLocker
    • UdpSocketAddr is fully constructed with V4MAPPED address
    • iVecSizeOut = 1026
    • bIPv6Available = true
    • Socket is in blocking mode (fcntl not called to set O_NONBLOCK)

    The next log line (>> sendto (V4MAPPED) returned: status= -1) appears 50+ seconds later, after the process was unpaused from the Xcode debugger. The kernel did not sleep for 50 seconds — the process was suspended by the debugger.

    When the process resumes (unpaused), sendto returns in milliseconds (4ms for the retry), proving the kernel was not responsible for the delay. The 50-second gap was entirely due to the debugger pause.

  17. pljones commented on Jul 4, 2026

    @pljones
    Collaborator

    O_NONBLOCK= NOT SET -- What does this do on BSD / macOS for UDP?

    The kernel did not sleep for 50 seconds — the process was suspended by the debugger.

    This is noise from the LLM, right? It keeps repeating it but it's not actually useful. Why did the debugger pause?

  18. ann0see commented on Jul 4, 2026

    @ann0see
    MemberAuthor

    Yes it's noise from the LLM. I paused it manually via Xcode.

  19. ann0see commented on Jul 4, 2026

    @ann0see
    MemberAuthor
  20. pljones commented on Jul 4, 2026

    @pljones
    Collaborator

    https://stackoverflow.com/questions/2889901/is-o-nonblock-being-set-a-property-of-the-file-descriptor-or-underlying-file

    I think it's a parameter for blocking/non blocking io.

    Mmm. I guess it's a bit like a disk write: "stick the content of this buffer onto the outbound network and don't come back until you've finished" (with O_NONBLOCK not set). So if there's something wrong with the descriptor of the buffer (like the header) and something breaks, you find out. With O_NONBLOCK true, you'd need some other way to know whether the network call succeeded.

    So I guess my question is "how do you handle a call when O_NONBLOCK is true compared to when O_NONBLOCK is false for a UDP packet sendto() on macOS/BSD?"

    Note

    Claude says

    UDP sendto() behavior with O_NONBLOCK on macOS/BSD

    Source: Claude
    Date: 04/07/2026, 18:13:12
    Link: https://claude.ai/chat/85aa6eac-8036-4f47-b392-8fd0bda06322
    Model: claude-sonnet-5

    Prompt:

    how do you handle a call when O_NONBLOCK is true compared to when O_NONBLOCK is false for a UDP packet sendto() on macOS/BSD?

    Response:

    Blocking (default, O_NONBLOCK not set)

    If the socket send buffer doesn't have room for the packet, sendto() blocks the calling thread until space becomes available (or until a signal interrupts it). For UDP this is rare — it mostly happens when you're sending faster than the interface/driver can drain the socket buffer (SO_SNDBUF), not because of a remote receiver (UDP has no flow control back to the sender).

    Non-blocking (O_NONBLOCK set)

    If the send buffer can't accept the packet immediately, sendto() returns -1 immediately and sets errno = EWOULDBLOCK (== EAGAIN on macOS/BSD). It never blocks the thread.

    Practical edge cases to test/handle

    1. Oversized datagram: If the packet exceeds what the socket/route can send (larger than the max UDP payload for the path, e.g. >65507 bytes, or exceeding IP_MAXPACKET constraints), you get EMSGSIZE — this happens regardless of O_NONBLOCK, immediately, not a blocking condition at all.

    2. No local buffer space: ENOBUFS can occur on BSD/macOS when the interface queue is full — this is distinct from EWOULDBLOCK. It can happen even on a blocking socket in some driver-queue-full scenarios (particularly with high packet rates), so don't assume blocking sockets never return an error for buffer issues.

    3. ICMP-derived errors on "connected" UDP sockets: If you called connect() on the UDP socket, a prior ICMP "port unreachable" can cause a subsequent sendto()/send() to return ECONNREFUSED — this is asynchronous and independent of blocking mode.

    4. Signal interruption: A blocking sendto() can return -1/EINTR if interrupted by a signal before space is available — always check for and retry on EINTR in blocking code.

    5. Partial sends don't apply to UDP: unlike TCP, a successful sendto() return value is always the full datagram size or an error — no partial-write handling needed.

    Testing this yourself

    // force EWOULDBLOCK reproducibly: shrink SO_SNDBUF, then flood sendto() in a tight loop
    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
    
    int sndbuf = 2048; // tiny, to make exhaustion easy to trigger
    setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));
    
    for (;;) {
        ssize_t n = sendto(fd, buf, len, 0, (struct sockaddr*)&dst, sizeof(dst));
        if (n < 0) {
            if (errno == EWOULDBLOCK) { /* expected under non-blocking + full buffer */ }
            else if (errno == EMSGSIZE) { /* packet too large */ }
            else if (errno == ENOBUFS) { /* driver/interface queue full */ }
            else perror("sendto");
        }
    }

    Run the same loop without O_NONBLOCK and you should observe the loop's throughput throttle down (blocking) instead of returning errors — a good way to confirm the behavioral difference empirically on your system.

    One caveat worth flagging: exact errno behavior for ENOBUFS vs EWOULDBLOCK under buffer pressure can vary slightly between macOS versions and other BSDs (FreeBSD/OpenBSD), so if this is for production code, check man 2 send on the specific target OS rather than assuming Linux-style semantics apply.

  21. added this to the Release 4.0.0 milestone on Jul 4, 2026
  22. ann0see commented on Jul 10, 2026

    @ann0see
    MemberAuthor

    I might be related to the SRV lookup - not sure. I had a slight hang (short) while trying over a ipv4 only + ipv6 over vpn connection. I'll try what happens with the #3774 version.

    • allocated port number: 22134
      IPv6/IPv4 dual-stack socket created
      qt.multimedia.ffmpeg: Using Qt multimedia with FFmpeg version 7.1.2 LGPL version 2.1 or later
      resolved choral.jamulus.io to a single SRV record: choral.jamulus.io:22724
      resolved choral.jamulus.io to a single SRV record: choral.jamulus.io:22724

    Server restarted?
    QThreadStorage: entry 1 destroyed before end of thread 0x102bb0390

  23. softins commented on Jul 10, 2026

    @softins
    Member

    I might be related to the SRV lookup - not sure. I had a slight hang (short) while trying over a ipv4 only + ipv6 over vpn connection. I'll try what happens with the #3774 version.

    • allocated port number: 22134
      IPv6/IPv4 dual-stack socket created
      qt.multimedia.ffmpeg: Using Qt multimedia with FFmpeg version 7.1.2 LGPL version 2.1 or later
      resolved choral.jamulus.io to a single SRV record: choral.jamulus.io:22724
      resolved choral.jamulus.io to a single SRV record: choral.jamulus.io:22724

    Server restarted?
    QThreadStorage: entry 1 destroyed before end of thread 0x102bb0390

    That doesn't look normal. Looking up the standard directories should not use SRV at all, as they have port numbers embedded in the app.

    The only reason SRV would be used in your example would be if choral.jamulus.io was given without port number as a custom directory.

  24. ann0see commented on Jul 11, 2026

    @ann0see
    MemberAuthor

    Correct. That could be.

  25. moved this from In Progress to Done in Trackingon Jul 15, 2026
  26. ann0see commented on Jul 15, 2026

    @ann0see
    MemberAuthor

    (will reopen if the bug comes up again - not in the respective network where this bug occurred for now)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

Labels

bugSomething isn't working

Type

Projects

  • Status
    Done

Relationships

None yet

Development

No branches or pull requests

Issue actions