Function runMainHeartbeat

src/hooks/usePipeIpc.ts:272–402

(
  pipeName: string,
  machineId: string,
  store: StoreApi,
  disposed: { current: boolean },
)

// ---------------------------------------------------------------------------

function runMainHeartbeat(
  pipeName: string,
  machineId: string,
  store: StoreApi,
  disposed: { current: boolean },
): void {
  void (async () => {
    try {
      await pr.cleanupStaleEntries()
      const aliveSubs = await pr.getAliveSubs()
      refreshDiscoveredPipes(pipeName, aliveSubs, store)

      const connectedSlaves = mm.getAllSlaveClients()
      const aliveSubNames = new Set(aliveSubs.map(sub => sub.pipeName))

      // Build unified attach target list: local subs + LAN peers
      type AttachTarget = {
        pipeName: string
        tcpEndpoint?: { host: string; port: number }
      }
      const attachTargets: AttachTarget[] = aliveSubs.map(sub => ({
        pipeName: sub.pipeName,
      }))

      // Add LAN peers as attach targets
      if (feature('LAN_PIPES')) {
        const beacon = lb.getLanBeacon()
        if (beacon) {
          const localNames = new Set(attachTargets.map(t => t.pipeName))
          localNames.add(pipeName)
          for (const [pName, peer] of beacon.getPeers()) {
            if (!localNames.has(pName)) {
              attachTargets.push({
                pipeName: pName,
                tcpEndpoint: { host: peer.ip, port: peer.tcpPort },
              })
              aliveSubNames.add(pName)
            }
          }
        }
      }

      const currentPipeState = pt.getPipeIpc(store.getState())

      for (const target of attachTargets) {
        if (target.pipeName === pipeName) continue
        if (connectedSlaves.has(target.pipeName)) continue

        try {
          const myName = currentPipeState.serverName ?? pipeName
          const client = await pt.connectToPipe(
            target.pipeName,
            myName,
            3000,
            target.tcpEndpoint,
          )

          const attached = await new Promise<boolean>(resolve => {